[要約] RFC 6386は、VP8データ形式とデコードガイドに関する技術仕様です。このRFCの目的は、VP8ビデオコーデックのデータ形式とデコード方法を詳細に説明し、実装者に役立つ情報を提供することです。
Independent Submission J. Bankoski
Request for Comments: 6386 J. Koleszar
Category: Informational L. Quillio
ISSN: 2070-1721 J. Salonen
P. Wilkins
Y. Xu
Google Inc.
November 2011
VP8 Data Format and Decoding Guide
VP8データ形式とデコードガイド
Abstract
概要
This document describes the VP8 compressed video data format, together with a discussion of the decoding procedure for the format.
このドキュメントでは、VP8圧縮ビデオデータ形式と、形式のデコード手順の説明について説明します。
Status of This Memo
本文書の位置付け
This document is not an Internet Standards Track specification; it is published for informational purposes.
このドキュメントは、インターネット標準の追跡仕様ではありません。情報目的で公開されています。
This is a contribution to the RFC Series, independently of any other RFC stream. The RFC Editor has chosen to publish this document at its discretion and makes no statement about its value for implementation or deployment. Documents approved for publication by the RFC Editor are not a candidate for any level of Internet Standard; see Section 2 of RFC 5741.
これは、他のRFCストリームとは無関係に、RFCシリーズへの貢献です。RFCエディターは、このドキュメントの裁量でこのドキュメントを公開することを選択しており、実装または展開に対する価値について声明を発表しません。RFCエディターによって公開が承認されたドキュメントは、インターネット標準のレベルの候補者ではありません。RFC 5741のセクション2を参照してください。
Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at http://www.rfc-editor.org/info/rfc6386.
このドキュメントの現在のステータス、任意のERRATA、およびそのフィードバックを提供する方法に関する情報は、http：//www.rfc-editor.org/info/rfc6386で取得できます。
Copyright Notice
著作権表示
Copyright (c) 2011 IETF Trust and the persons identified as the document authors. All rights reserved.
Copyright（c）2011 IETF Trustおよび文書著者として特定された人。全著作権所有。
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document.
このドキュメントは、BCP 78およびIETFドキュメント（http://trustee.ietf.org/license-info）に関連するIETF Trustの法的規定の対象となります。この文書に関するあなたの権利と制限を説明するので、これらの文書を注意深く確認してください。
Table of Contents
目次
1. Introduction ....................................................4
2. Format Overview .................................................5
3. Compressed Frame Types ..........................................7
4. Overview of Compressed Data Format ..............................8
5. Overview of the Decoding Process ................................9
6. Description of Algorithms ......................................14
7. Boolean Entropy Decoder ........................................16
7.1. Underlying Theory of Coding ...............................17
7.2. Practical Algorithm Description ...........................18
7.3. Actual Implementation .....................................20
8. Compressed Data Components .....................................25
8.1. Tree Coding Implementation ................................27
8.2. Tree Coding Example .......................................28
9. Frame Header ...................................................30
9.1. Uncompressed Data Chunk ...................................30
9.2. Color Space and Pixel Type (Key Frames Only) ..............33
9.3. Segment-Based Adjustments .................................34
9.4. Loop Filter Type and Levels ...............................35
9.5. Token Partition and Partition Data Offsets ................36
9.6. Dequantization Indices ....................................37
9.7. Refresh Golden Frame and Altref Frame .....................38
9.8. Refresh Last Frame Buffer .................................39
9.9. DCT Coefficient Probability Update ........................39
9.10. Remaining Frame Header Data (Non-Key Frame) ..............40
9.11. Remaining Frame Header Data (Key Frame) ..................41
10. Segment-Based Feature Adjustments .............................41
11. Key Frame Macroblock Prediction Records .......................42
11.1. mb_skip_coeff ............................................42
11.2. Luma Modes ...............................................42
11.3. Subblock Mode Contexts ...................................45
11.4. Chroma Modes .............................................46
11.5. Subblock Mode Probability Table ..........................47
12. Intraframe Prediction .........................................50
12.1. mb_skip_coeff ............................................51
12.2. Chroma Prediction ........................................51
12.3. Luma Prediction ..........................................54
13. DCT Coefficient Decoding ......................................60
13.1. Macroblock without Non-Zero Coefficient Values ...........61
13.2. Coding of Individual Coefficient Values ..................61
13.3. Token Probabilities ......................................63
13.4. Token Probability Updates ................................68
13.5. Default Token Probability Table ..........................73
14. DCT and WHT Inversion and Macroblock Reconstruction ...........76
14.1. Dequantization ...........................................76
14.2. Inverse Transforms .......................................78
14.3. Implementation of the WHT Inversion ......................78
14.4. Implementation of the DCT Inversion ......................81
14.5. Summation of Predictor and Residue .......................83
15. Loop Filter ...................................................84
15.1. Filter Geometry and Overall Procedure ....................85
15.2. Simple Filter ............................................87
15.3. Normal Filter ............................................91
15.4. Calculation of Control Parameters ........................95
16. Interframe Macroblock Prediction Records ......................97
16.1. Intra-Predicted Macroblocks ..............................97
16.2. Inter-Predicted Macroblocks ..............................98
16.3. Mode and Motion Vector Contexts ..........................99
16.4. Split Prediction ........................................105
17. Motion Vector Decoding .......................................108
17.1. Coding of Each Component ................................108
17.2. Probability Updates .....................................110
18. Interframe Prediction ........................................113
18.1. Bounds on, and Adjustment of, Motion Vectors ............113
18.2. Prediction Subblocks ....................................115
18.3. Sub-Pixel Interpolation .................................115
18.4. Filter Properties .......................................118
19. Annex A: Bitstream Syntax ....................................120
19.1. Uncompressed Data Chunk .................................121
19.2. Frame Header ............................................122
19.3. Macroblock Data .........................................130
20. Attachment One: Reference Decoder Source Code ................133
20.1. bit_ops.h ...............................................133
20.2. bool_decoder.h ..........................................133
20.3. dequant_data.h ..........................................137
20.4. dixie.c .................................................138
20.5. dixie.h .................................................151
20.6. dixie_loopfilter.c ......................................158
20.7. dixie_loopfilter.h ......................................170
20.8. idct_add.c ..............................................171
20.9. idct_add.h ..............................................174
20.10. mem.h ..................................................175
20.11. modemv.c ...............................................176
20.12. modemv.h ...............................................192
20.13. modemv_data.h ..........................................193
20.14. predict.c ..............................................198
20.15. predict.h ..............................................231
20.16. tokens.c ...............................................232
20.17. tokens.h ...............................................242
20.18. vp8_prob_data.h ........................................243
20.19. vpx_codec_internal.h ...................................252
20.20. vpx_decoder.h ..........................................263
20.21. vpx_decoder_compat.h ...................................271
20.22. vpx_image.c ............................................285
20.23. vpx_image.h ............................................291
20.24. vpx_integer.h ..........................................298
20.25. AUTHORS File ...........................................299
20.26. LICENSE ................................................301
20.27. PATENTS ................................................302
21. Security Considerations ......................................302
22. References ...................................................303
22.1. Normative Reference .....................................303
22.2. Informative References ..................................303
This document describes the VP8 compressed video data format, together with a discussion of the decoding procedure for the format. It is intended to be used in conjunction with, and as a guide to, the reference decoder source code provided in Attachment One (Section 20). If there are any conflicts between this narrative and the reference source code, the reference source code should be considered correct. The bitstream is defined by the reference source code and not this narrative.
このドキュメントでは、VP8圧縮ビデオデータ形式と、形式のデコード手順の説明について説明します。これは、添付ファイル1（セクション20）で提供される参照デコーダーソースコードと連携して、およびガイドとして使用することを目的としています。この物語と参照ソースコードの間に競合がある場合、参照ソースコードを正しいと見なす必要があります。ビットストリームは、この物語ではなく、参照ソースコードによって定義されます。
Like many modern video compression schemes, VP8 is based on decomposition of frames into square subblocks of pixels, prediction of such subblocks using previously constructed blocks, and adjustment of such predictions (as well as synthesis of unpredicted blocks) using a discrete cosine transform (hereafter abbreviated as DCT). In one special case, however, VP8 uses a Walsh-Hadamard transform (hereafter abbreviated as WHT) instead of a DCT.
多くの最新のビデオ圧縮スキームと同様に、VP8は、ピクセルの四角いサブブロックへのフレームの分解、以前に構築されたブロックを使用したそのようなサブブロックの予測、およびそのような予測の調整（および予測されていないブロックの合成）に基づいています。DCTとして略された）。ただし、1つの特別なケースでは、VP8はDCTの代わりにWalsh-Hadamard Transform（以下WHTとして略された）を使用します。
Roughly speaking, such systems reduce datarate by exploiting the temporal and spatial coherence of most video signals. It is more efficient to specify the location of a visually similar portion of a prior frame than it is to specify pixel values. The frequency segregation provided by the DCT and WHT facilitates the exploitation of both spatial coherence in the original signal and the tolerance of the human visual system to moderate losses of fidelity in the reconstituted signal.
大まかに言えば、このようなシステムは、ほとんどのビデオ信号の時間的および空間的な一貫性を活用することにより、データレー酸塩を減らします。ピクセル値を指定するよりも、以前のフレームの視覚的に類似した部分の位置を指定する方が効率的です。DCTによって提供される周波数分離とWHTは、元の信号における空間的コヒーレンスの両方の搾取と、再構成された信号の忠実度の緩和の緩和に対するヒトの視覚システムの耐性の両方を促進します。
VP8 augments these basic concepts with, among other things, sophisticated usage of contextual probabilities. The result is a significant reduction in datarate at a given quality.
VP8は、これらの基本的な概念を、とりわけ、コンテキスト確率の洗練された使用法で拡張します。その結果、特定の品質でデータレートが大幅に減少します。
Unlike some similar schemes (the older MPEG formats, for example), VP8 specifies exact values for reconstructed pixels. Specifically, the specification for the DCT and WHT portions of the reconstruction does not allow for any "drift" caused by truncation of fractions. Rather, the algorithm is specified using fixed-precision integer operations exclusively. This greatly facilitates the verification of the correctness of a decoder implementation and also avoids difficult-to-predict visual incongruities between such implementations.
いくつかの同様のスキーム（古いMPEG形式など）とは異なり、VP8は再構築されたピクセルの正確な値を指定します。具体的には、再構築のDCTおよびWHT部分の仕様では、画分の切り捨てによって引き起こされる「ドリフト」は許可されていません。むしろ、アルゴリズムは、固定精度の整数操作のみを使用して指定されます。これにより、デコーダーの実装の正確性の検証が大幅に促進され、このような実装間の予測が困難な視覚的不一致を回避します。
It should be remarked that, in a complete video playback system, the displayed frames may or may not be identical to the reconstructed frames. Many systems apply a final level of filtering (commonly referred to as postprocessing) to the reconstructed frames prior to viewing. Such postprocessing has no effect on the decoding and reconstruction of subsequent frames (which are predicted using the completely specified reconstructed frames) and is beyond the scope of this document. In practice, the nature and extent of this sort of postprocessing is dependent on both the taste of the user and on the computational facilities of the playback environment.
完全なビデオ再生システムでは、表示されているフレームが再構築されたフレームと同一である場合と同一でない場合がある場合があることに注意する必要があります。多くのシステムは、視聴前に再構築されたフレームに最終レベルのフィルタリング（一般にポストプロセッシングと呼ばれる）を適用します。このような後処理は、後続のフレーム（完全に指定された再構築されたフレームを使用して予測される）のデコードと再構築に影響を与えず、このドキュメントの範囲を超えています。実際には、この種のポストプロセスの性質と範囲は、ユーザーの味と再生環境の計算施設の両方に依存しています。
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [RFC2119].
この文書のキーワード "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", および "OPTIONAL" はRFC 2119 [RFC2119]で説明されているように解釈されます。
VP8 works exclusively with an 8-bit YUV 4:2:0 image format. In this format, each 8-bit pixel in the two chroma planes (U and V) corresponds positionally to a 2x2 block of 8-bit luma pixels in the Y plane; coordinates of the upper left corner of the Y block are of course exactly twice the coordinates of the corresponding chroma pixels. When we refer to pixels or pixel distances without specifying a plane, we are implicitly referring to the Y plane or to the complete image, both of which have the same (full) resolution.
VP8は、8ビットYUV 4：2：0の画像形式でのみ機能します。この形式では、2つのクロマ平面（UとV）の各8ビットピクセルは、Y平面の8ビットLUMAピクセルの2x2ブロックに位置的に対応します。Yブロックの左上隅の座標は、もちろん、対応するクロマピクセルの座標の正確な2倍です。平面を指定せずにピクセルまたはピクセル距離を参照する場合、Y平面または完全な画像を暗黙的に参照します。どちらも同じ（完全な）解像度を持っています。
As is usually the case, the pixels are simply a large array of bytes stored in rows from top to bottom, each row being stored from left to right. This "left to right" then "top to bottom" raster-scan order is reflected in the layout of the compressed data as well.
通常のように、ピクセルは単に上から下まで行に保存されたバイトの大きな配列であり、各列は左から右に保存されます。この「左から右」、次に「上から下」ラスタースキャンの順序は、圧縮データのレイアウトにも反映されます。
Provision has been made in the VP8 bitstream header for the support of a secondary YUV color format, in the form of a reserved bit.
予約ビットの形で、二次YUVカラー形式のサポートのために、VP8ビットストリームヘッダーで提供されています。
Occasionally, at very low datarates, a compression system may decide to reduce the resolution of the input signal to facilitate efficient compression. The VP8 data format supports this via optional upscaling of its internal reconstruction buffer prior to output (this
時折、非常に低いデータレートで、圧縮システムは、効率的な圧縮を容易にするために入力信号の解像度を減らすことを決定する場合があります。VP8データ形式は、出力前に内部再構成バッファーのオプションのアップスケーリングを介してこれをサポートしています（これ
is completely distinct from the optional postprocessing discussed earlier, which has nothing to do with decoding per se). This upsampling restores the video frames to their original resolution. In other words, the compression/decompression system can be viewed as a "black box", where the input and output are always at a given resolution. The compressor might decide to "cheat" and process the signal at a lower resolution. In that case, the decompressor needs the ability to restore the signal to its original resolution.
前述のオプションのポストプロセスとは完全に異なりますが、それ自体を解読することとは関係ありません）。このアップサンプリングにより、ビデオフレームが元の解像度に復元されます。言い換えれば、圧縮/減圧システムは「ブラックボックス」と見なすことができ、入力と出力は常に特定の解像度にあります。コンプレッサーは、低解像度で「チート」して信号を処理することを決定する場合があります。その場合、減圧装置は、信号を元の解像度に復元する機能を必要とします。
Internally, VP8 decomposes each output frame into an array of macroblocks. A macroblock is a square array of pixels whose Y dimensions are 16x16 and whose U and V dimensions are 8x8. Macroblock-level data in a compressed frame occurs (and must be processed) in a raster order similar to that of the pixels comprising the frame.
内部的には、VP8は各出力フレームをマクロブロックの配列に分解します。マクロブロックは、y寸法が16x16であり、uおよびv寸法が8x8であるピクセルの正方形の配列です。圧縮フレームのマクロブロックレベルのデータは、フレームを構成するピクセルと同様のラスター順序で発生します（および処理する必要があります）。
Macroblocks are further decomposed into 4x4 subblocks. Every macroblock has 16 Y subblocks, 4 U subblocks, and 4 V subblocks. Any subblock-level data (and processing of such data) again occurs in raster order, this time in raster order within the containing macroblock.
マクロブロックは、さらに4x4サブブロックに分解されます。すべてのマクロブロックには、16のサブブロック、4つのUサブブロック、4つのVサブブロックがあります。サブブロックレベルのデータ（およびそのようなデータの処理）は、再びラスター順序で発生します。今回は、マクロブロックを含むラスター順序で発生します。
As discussed in further detail below, data can be specified at the levels of both macroblocks and their subblocks.
以下でさらに詳しく説明するように、データはマクロブロックとそのサブブロックの両方のレベルで指定できます。
Pixels are always treated, at a minimum, at the level of subblocks, which may be thought of as the "atoms" of the VP8 algorithm. In particular, the 2x2 chroma blocks corresponding to 4x4 Y subblocks are never treated explicitly in the data format or in the algorithm specification.
ピクセルは常に、少なくともサブブロックのレベルで処理されます。これは、VP8アルゴリズムの「原子」と考えられる可能性があります。特に、4x4 Yサブブロックに対応する2x2クロマブロックは、データ形式またはアルゴリズム仕様で明示的に扱われることはありません。
The DCT and WHT always operate at a 4x4 resolution. The DCT is used for the 16Y, 4U, and 4V subblocks. The WHT is used (with some but not all prediction modes) to encode a 4x4 array comprising the average intensities of the 16 Y subblocks of a macroblock. These average intensities are, up to a constant normalization factor, nothing more than the 0th DCT coefficients of the Y subblocks. This "higher-level" WHT is a substitute for the explicit specification of those coefficients, in exactly the same way as the DCT of a subblock substitutes for the specification of the pixel values comprising the subblock. We consider this 4x4 array as a second-order subblock called Y2, and think of a macroblock as containing 24 "real" subblocks and, sometimes, a 25th "virtual" subblock. This is dealt with further in Section 13.
DCTとWHTは常に4x4解像度で動作します。DCTは、16Y、4U、および4Vサブブロックに使用されます。WHTは（すべてではないが一部ではないが一部ではありませんが）使用され、マクロブロックの16Yサブブロックの平均強度を含む4x4アレイをエンコードします。これらの平均強度は、一定の正規化係数まで、Yサブブロックの0番目のDCT係数にすぎません。この「高レベルの」WHTは、サブブロックを含むピクセル値の仕様のサブブロックのDCTとまったく同じ方法で、これらの係数の明示的な仕様の代替品です。この4x4アレイはY2と呼ばれる2次サブブロックと見なし、マクロブロックを24の「本物の」サブブロックを含むと考えています。これは、セクション13でさらに扱われます。
The frame layout used by the reference decoder may be found in the file vpx_image.h (Section 20.23).
参照デコーダーで使用されるフレームレイアウトは、ファイルvpx_image.h（セクション20.23）に記載されている場合があります。
There are only two types of frames in VP8.
VP8にはフレームには2種類しかありません。
Intraframes (also called key frames and, in MPEG terminology, I-frames) are decoded without reference to any other frame in a sequence; that is, the decompressor reconstructs such frames beginning from its "default" state. Key frames provide random access (or seeking) points in a video stream.
イントラフレーム（キーフレームとも呼ばれ、MPEG用語ではIフレームとも呼ばれます）は、シーケンス内の他のフレームを参照せずにデコードされます。つまり、減圧器は「デフォルト」状態から始まるそのようなフレームを再構築します。キーフレームは、ビデオストリームでランダムアクセス（またはシーク）ポイントを提供します。
Interframes (also called prediction frames and, in MPEG terminology, P-frames) are encoded with reference to prior frames, specifically all prior frames up to and including the most recent key frame. Generally speaking, the correct decoding of an interframe depends on the correct decoding of the most recent key frame and all ensuing frames. Consequently, the decoding algorithm is not tolerant of dropped frames: In an environment in which frames may be dropped or corrupted, correct decoding will not be possible until a key frame is correctly received.
インターフレーム（予測フレームとも呼ばれ、MPEG用語ではPフレームとも呼ばれます）は、以前のフレーム、特に最新のキーフレームまでのすべての以前のフレームを参照してエンコードされます。一般的に言えば、インターフレームの正しいデコードは、最新のキーフレームとその後のすべてのフレームの正しいデコードに依存します。その結果、デコードアルゴリズムはドロップされたフレームに対して耐性がありません。フレームをドロップまたは破損する環境では、キーフレームが正しく受信されるまで正しいデコードは不可能です。
In contrast to MPEG, there is no use of bidirectional prediction. No frame is predicted using frames temporally subsequent to it; there is no analog to an MPEG B-frame.
MPEGとは対照的に、双方向の予測には使用されていません。フレームは、それに続いて一時的にフレームを使用して予測されることはありません。MPEG Bフレームのアナログはありません。
Secondly, VP8 augments these notions with that of alternate prediction frames, called golden frames and altref frames (alternative reference frames). Blocks in an interframe may be predicted using blocks in the immediately previous frame as well as the most recent golden frame or altref frame. Every key frame is automatically golden and altref, and any interframe may optionally replace the most recent golden or altref frame.
第二に、VP8はこれらの概念を、ゴールデンフレームとアルトレフフレーム（代替参照フレーム）と呼ばれる代替予測フレームの概念を補強します。インターフレーム内のブロックは、最新のフレームと最新のゴールデンフレームまたはアルトレフフレームのブロックを使用して予測できます。すべてのキーフレームは自動的に黄金色とアルトレフであり、任意のインターフレームはオプションで最新のゴールデンまたはアルトレフフレームを置き換えることができます。
Golden frames and altref frames may also be used to partially overcome the intolerance to dropped frames discussed above: If a compressor is configured to code golden frames only with reference to the prior golden frame (and key frame), then the "substream" of key and golden frames may be decoded regardless of loss of other interframes. Roughly speaking, the implementation requires (on the compressor side) that golden frames subsume and recode any context updates effected by the intervening interframes. A typical application of this approach is video conferencing, in which retransmission of a prior golden frame and/or a delay in playback until receipt of the next golden frame is preferable to a larger retransmit and/or delay until the next key frame.
ゴールデンフレームとアルトレフフレームは、上記のドロップフレームへの不寛容を部分的に克服するためにも使用できます。コンプレッサーが以前のゴールデンフレーム（およびキーフレーム）、次にキーの「サブストリーム」を参照してゴールデンフレームをコードするように構成されている場合また、他のインターフレームの損失に関係なく、ゴールデンフレームはデコードされる場合があります。大まかに言えば、実装では（コンプレッサー側）、ゴールデンフレームが介入するインターフレームによって行われたコンテキストの更新を補充して再コーディングする必要があります。このアプローチの典型的なアプリケーションは、ビデオ会議です。これは、以前のゴールデンフレームの再送信および/または次のゴールデンフレームの受領が次のキーフレームまで大きな再送信および/または遅延よりも好ましいです。
The input to a VP8 decoder is a sequence of compressed frames whose order matches their order in time. Issues such as the duration of frames, the corresponding audio, and synchronization are generally provided by the playback environment and are irrelevant to the decoding process itself; however, to aid in fast seeking, a start code is included in the header of each key frame.
VP8デコーダーへの入力は、順序が時間内に順序と一致する圧縮フレームのシーケンスです。フレームの期間、対応するオーディオ、同期などの問題は、一般に再生環境によって提供され、デコードプロセス自体とは無関係です。ただし、高速探索を支援するために、各キーフレームのヘッダーに開始コードが含まれています。
The decoder is simply presented with a sequence of compressed frames and produces a sequence of decompressed (reconstructed) YUV frames corresponding to the input sequence. As stated in the Introduction, the exact pixel values in the reconstructed frame are part of VP8's specification. This document specifies the layout of the compressed frames and gives unambiguous algorithms for the correct production of reconstructed frames.
デコーダーは、圧縮フレームのシーケンスで単純に表示され、入力シーケンスに対応する減圧（再構築された）YUVフレームのシーケンスを生成します。導入部で述べたように、再構築されたフレームの正確なピクセル値はVP8の仕様の一部です。このドキュメントは、圧縮フレームのレイアウトを指定し、再構築されたフレームの正しい生産のための明確なアルゴリズムを提供します。
The first frame presented to the decompressor is of course a key frame. This may be followed by any number of interframes; the correct reconstruction of each frame depends on all prior frames up to the key frame. The next key frame restarts this process: The decompressor resets to its default initial condition upon reception of a key frame, and the decoding of a key frame (and its ensuing interframes) is completely independent of any prior decoding.
減圧器に提示された最初のフレームは、もちろん重要なフレームです。これに続いて、任意の数のインターフレームが続く場合があります。各フレームの正しい再構築は、キーフレームまでのすべての以前のフレームに依存します。次のキーフレームはこのプロセスを再起動します。減圧器は、キーフレームを受信するとデフォルトの初期条件にリセットされ、キーフレーム（およびその後のインターフレーム）のデコードは、以前のデコードとは完全に独立しています。
At the highest level, every compressed frame has three or more pieces. It begins with an uncompressed data chunk comprising 10 bytes in the case of key frames and 3 bytes for interframes. This is followed by two or more blocks of compressed data (called partitions). These compressed data partitions begin and end on byte boundaries.
最高レベルでは、すべての圧縮フレームには3つ以上のピースがあります。キーフレームの場合は10バイト、インターフレームの3バイトで構成される非圧縮データチャンクから始まります。これに続いて、圧縮データの2つ以上のブロック（パーティションと呼ばれます）が続きます。これらの圧縮データパーティションは、バイト境界で開始および終了します。
The first compressed partition has two subsections:
最初の圧縮パーティションには2つのサブセクションがあります。
1. Header information that applies to the frame as a whole.
1. フレーム全体に適用されるヘッダー情報。
2. Per-macroblock information specifying how each macroblock is predicted from the already-reconstructed data that is available to the decompressor.
2. マクロブロックごとの情報は、減圧器が利用できる既に再構築されたデータから各マクロブロックがどのように予測されるかを指定します。
As stated above, the macroblock-level information occurs in raster-scan order.
上記のように、マクロブロックレベルの情報はラスタースキャンの順序で発生します。
The rest of the partitions contain, for each block, the DCT/WHT coefficients (quantized and logically compressed) of the residue signal to be added to the predicted block values. It typically accounts for roughly 70% of the overall datarate. VP8 supports packing the compressed DCT/WHT coefficients' data from macroblock
パーティションの残りの部分には、各ブロックに対して、予測ブロック値に追加される残基信号のDCT/WHT係数（量子化および論理的に圧縮）が含まれています。通常、全体的なデータレートの約70％を占めています。VP8は、マクロブロックからの圧縮DCT/WHT係数のデータの梱包をサポートしています
rows into separate partitions. If there is more than one partition for these coefficients, the sizes of the partitions -- except the last partition -- in bytes are also present in the bitstream right after the above first partition. Each of the sizes is a 3-byte data item written in little endian format. These sizes provide the decoder direct access to all DCT/WHT coefficient partitions, which enables parallel processing of the coefficients in a decoder.
別々のパーティションに列。これらの係数に複数のパーティションがある場合、最後のパーティションを除くパーティションのサイズは、上記の最初のパーティションの直後にビットストリームにも存在します。各サイズは、リトルエンド形式で記述された3バイトのデータ項目です。これらのサイズは、すべてのDCT/WHT係数パーティションへのデコーダー直接アクセスを提供します。これにより、デコーダー内の係数の並列処理が可能になります。
The separate partitioning of the prediction data and coefficient data also allows flexibility in the implementation of a decompressor: An implementation may decode and store the prediction information for the whole frame and then decode, transform, and add the residue signal to the entire frame, or it may simultaneously decode both partitions, calculating prediction information and adding in the residue signal for each block in order. The length field in the frame tag, which allows decoding of the second partition to begin before the first partition has been completely decoded, is necessary for the second "block-at-a-time" decoder implementation.
予測データと係数データの個別のパーティション化により、減圧装置の実装に柔軟性が可能になります。実装は、フレーム全体の予測情報をデコードして保存し、フレーム全体に残基信号をデコード、変換、追加することができます。両方のパーティションをデコードし、予測情報を計算し、各ブロックの残基信号を順に追加することができます。2番目のパーティションが完全にデコードされる前に2番目のパーティションのデコードを開始できるフレームタグ内の長さフィールドは、2番目の「ブロックAT-A-A-AT-A-A-AT-A」デコーダー実装に必要です。
All partitions are decoded using separate instances of the boolean entropy decoder described in Section 7. Although some of the data represented within the partitions is conceptually "flat" (a bit is just a bit with no probabilistic expectation one way or the other), because of the way such coders work, there is never a direct correspondence between a "conceptual bit" and an actual physical bit in the compressed data partitions. Only in the 3- or 10-byte uncompressed chunk described above is there such a physical correspondence.
すべてのパーティションは、セクション7で説明されているブールエントロピーデコーダーの個別のインスタンスを使用してデコードされます。パーティション内で表されるデータの一部は概念的に「フラット」です（ほんの少しだけ確率的な期待がない場合は少しだけです）。そのようなコーダーの仕組みについては、「概念的なビット」と圧縮データパーティションの実際の物理的ビットとの間に直接的な対応がありません。上記の3バイトまたは10バイトの非圧縮チャンクでのみ、そのような物理的対応があります。
A related matter is that seeking within a partition is not supported. The data must be decompressed and processed (or at least stored) in the order in which it occurs in the partition.
関連する問題は、パーティション内を探すことがサポートされていないことです。データは、パーティションで発生する順序で解凍および処理（または少なくとも保存）する必要があります。
While this document specifies the ordering of the partition data correctly, the details and semantics of this data are discussed in a more logical fashion to facilitate comprehension. For example, the frame header contains updates to many probability tables used in decoding per-macroblock data. The per-macroblock data is often described before the layouts of the probabilities and their updates, even though this is the opposite of their order in the bitstream.
このドキュメントはパーティションデータの順序付けを正しく指定していますが、このデータの詳細とセマンティクスは、理解を促進するために、より論理的な方法で説明されています。たとえば、フレームヘッダーには、マクロブロックごとのデータのデコードに使用される多くの確率テーブルへの更新が含まれています。マクロブロックごとのデータは、ビットストリームでの注文の反対であるにもかかわらず、確率とその更新のレイアウトの前にしばしば説明されます。
A VP8 decoder needs to maintain four YUV frame buffers whose resolutions are at least equal to that of the encoded image. These buffers hold the current frame being reconstructed, the immediately previous reconstructed frame, the most recent golden frame, and the most recent altref frame.
VP8デコーダーは、エンコードされた画像の解像度と少なくとも等しい4つのYUVフレームバッファーを維持する必要があります。これらのバッファーは、再構築されている現在のフレーム、前回の再構築されたフレーム、最新のゴールデンフレーム、および最新のAltrefフレームを保持します。
Most implementations will wish to "pad" these buffers with "invisible" pixels that extend a moderate number of pixels beyond all four edges of the visible image. This simplifies interframe prediction by allowing all (or most) prediction blocks -- which are not guaranteed to lie within the visible area of a prior frame -- to address usable image data.
ほとんどの実装では、これらのバッファーを「目に見えない」ピクセルで「パッド」し、可視画像の4つのエッジすべてを超える中程度のピクセルを伸ばします。これにより、使用可能な画像データに対処するために、以前のフレームの可視領域内にあるすべての（またはほとんどの）予測ブロックを許可することにより、フレーム間予測が簡素化されます。
Regardless of the amount of padding chosen, the invisible rows above (or below) the image are filled with copies of the top (or bottom) row of the image; the invisible columns to the left (or right) of the image are filled with copies of the leftmost (or rightmost) visible row; and the four invisible corners are filled with copies of the corresponding visible corner pixels. The use of these prediction buffers (and suggested sizes for the halo) will be elaborated on in the discussion of motion vectors, interframe prediction, and sub-pixel interpolation later in this document.
選択したパディングの量に関係なく、画像の上（または下）の目に見えない行は、画像の上部（または下部）行のコピーで満たされています。画像の左（または右）の目に見えない列には、左端（または右端）の目に見える行のコピーが入っています。そして、4つの目に見えないコーナーには、対応する可視コーナーピクセルのコピーが入っています。これらの予測バッファーの使用（およびHALOの推奨サイズ）は、このドキュメントの後半でモーションベクトル、インターフレーム予測、およびサブピクセルの補間の議論で詳しく説明されます。
As will be seen in the description of the frame header, the image dimensions are specified (and can change) with every key frame. These buffers (and any other data structures whose size depends on the size of the image) should be allocated (or re-allocated) immediately after the dimensions are decoded.
フレームヘッダーの説明に見られるように、すべてのキーフレームで画像の寸法が指定されています（および変更される可能性があります）。これらのバッファー（およびサイズが画像のサイズに依存する他のデータ構造）は、寸法が解読された直後に割り当て（または再割り当て）する必要があります。
Leaving most of the details for later elaboration, the following is an outline of the decoding process.
詳細のほとんどを後の詳細のために残して、以下はデコードプロセスの概要です。
First, the frame header (the beginning of the first data partition) is decoded. Altering or augmenting the maintained state of the decoder, this provides the context in which the per-macroblock data can be interpreted.
まず、フレームヘッダー（最初のデータパーティションの開始）がデコードされます。デコーダーの維持状態を変更または増強すると、これにより、マクロブロックごとのデータを解釈できるコンテキストが提供されます。
The macroblock data occurs (and must be processed) in raster-scan order. This data comes in two or more parts. The first (prediction or mode) part comes in the remainder of the first data partition. The other parts comprise the data partition(s) for the DCT/WHT coefficients of the residue signal. For each macroblock, the prediction data must be processed before the residue.
マクロブロックデータは、ラスタースキャン順序で発生します（および処理する必要があります）。このデータには2つ以上の部分があります。最初の（予測またはモード）部分は、最初のデータパーティションの残りの部分にあります。他の部分は、残基信号のDCT/WHT係数のデータパーティションを構成します。各マクロブロックについて、予測データは残基の前に処理する必要があります。
Each macroblock is predicted using one (and only one) of four possible frames. All macroblocks in a key frame, and all intra-coded macroblocks in an interframe, are predicted using the already-decoded macroblocks in the current frame. Macroblocks in an interframe may also be predicted using the previous frame, the golden frame, or the altref frame. Such macroblocks are said to be inter-coded.
各マクロブロックは、4つの可能なフレームのうち1つ（および1つだけ）を使用して予測されます。キーフレーム内のすべてのマクロブロック、およびインターフレーム内のすべてのコード化されたマクロブロックは、現在のフレームの既にゼロのマクロブロックを使用して予測されます。インターフレーム内のマクロブロックは、以前のフレーム、ゴールデンフレーム、またはaltRefフレームを使用して予測することもできます。このようなマクロブロックは、インターコード化されていると言われています。
The purpose of prediction is to use already-constructed image data to approximate the portion of the original image being reconstructed. The effect of any of the prediction modes is then to write a macroblock-sized prediction buffer containing this approximation.
予測の目的は、すでに構成されている画像データを使用して、再構築されている元の画像の部分を近似することです。予測モードのいずれかの効果は、この近似を含むマクロブロックサイズの予測バッファーを記述することです。
Regardless of the prediction method, the residue DCT signal is decoded, dequantized, reverse-transformed, and added to the prediction buffer to produce the (almost final) reconstruction value of the macroblock, which is stored in the correct position of the current frame buffer.
予測方法に関係なく、残基DCT信号はデコード、非定量化、逆変換、および予測バッファーに追加され、現在のフレームバッファーの正しい位置に保存されているマクロブロックの（ほぼ最終的な）再構成値を生成します。。
The residue signal consists of 24 (sixteen Y, four U, and four V) 4x4 quantized and losslessly compressed DCT transforms approximating the difference between the original macroblock in the uncompressed source and the prediction buffer. For most prediction modes, the 0th coefficients of the sixteen Y subblocks are expressed via a 25th WHT of the second-order virtual Y2 subblock discussed above.
残基信号は、24（16 Y、4 U、および4つのV）4x4の量子化されていない圧縮されたDCT変換で構成され、非圧縮ソースの元のマクロブロックと予測バッファーの差に近似します。ほとんどの予測モードでは、16のYサブブロックの0番目の係数は、上記の2次仮想Y2サブブロックの25番目のWHTで表されます。
Intra-prediction exploits the spatial coherence of frames. The 16x16 luma (Y) and 8x8 chroma (UV) components are predicted independently of each other using one of four simple means of pixel propagation, starting from the already-reconstructed (16-pixel-long luma, 8-pixel-long chroma) row above, and column to the left of, the current macroblock. The four methods are:
予測内は、フレームの空間的一貫性を悪用します。16x16 Luma（y）および8x8 Chroma（UV）コンポーネントは、既に再構築された（16ピクセルの長さのLuma、8ピクセル長クロマ）から始まるピクセル伝播の4つの単純な手段のいずれかを使用して、互いに独立して予測されます。上の列、左側の列、現在のマクロブロック。4つの方法は次のとおりです。
1. Copying the row from above throughout the prediction buffer.
1. 予測バッファー全体で上から行をコピーします。
2. Copying the column from the left throughout the prediction buffer.
2. 予測バッファー全体で左から列をコピーします。
3. Copying the average value of the row and column throughout the prediction buffer.
3. 予測バッファー全体で行と列の平均値をコピーします。
4. Extrapolation from the row and column using the (fixed) second difference (horizontal and vertical) from the upper left corner.
4. 左上隅から（固定）2番目の差（水平および垂直）を使用して、行と列からの外挿。
Additionally, the sixteen Y subblocks may be predicted independently of each other using one of ten different modes, four of which are 4x4 analogs of those described above, augmented with six "diagonal" prediction methods. There are two types of predictions, one intra and one prediction (among all the modes), for which the residue signal does not use the Y2 block to encode the DC portion of the sixteen 4x4 Y subblock DCTs. This "independent Y subblock" mode has no effect on the 8x8 chroma prediction.
さらに、16のYサブブロックは、10の異なるモードのいずれかを使用して互いに独立して予測される場合があります。そのうち4つは上記の4x4アナログで、6つの「対角線」予測方法で補強されています。予測には、1つの予測と1つの予測（すべてのモードの間）の2つのタイプがあり、残基信号はY2ブロックを使用して16の4x4 YサブブロックDCTのDC部分をエンコードしません。この「独立したYサブブロック」モードは、8x8クロマ予測に影響を与えません。
Inter-prediction exploits the temporal coherence between nearby frames. Except for the choice of the prediction frame itself, there is no difference between inter-prediction based on the previous frame and that based on the golden frame or altref frame.
相互投与は、近くのフレーム間の時間的一貫性を悪用します。予測フレーム自体の選択を除いて、前のフレームに基づいた相互予測とゴールデンフレームまたはアルトレフフレームに基づく違いはありません。
Inter-prediction is conceptually very simple. While, for reasons of efficiency, there are several methods of encoding the relationship between the current macroblock and corresponding sections of the prediction frame, ultimately each of the sixteen Y subblocks is related to a 4x4 subblock of the prediction frame, whose position in that frame differs from the current subblock position by a (usually small) displacement. These two-dimensional displacements are called motion vectors.
相互投影は概念的に非常に単純です。効率の理由から、現在のマクロブロックと予測フレームの対応するセクションとの間に関係をエンコードする方法がいくつかありますが、最終的には16のYサブブロックのそれぞれが、そのフレームの位置の4x4サブブロックの4x4サブブロックに関連しています。現在のサブブロック位置とは、（通常は小さな）変位によって異なります。これらの2次元変位は、モーションベクトルと呼ばれます。
The motion vectors used by VP8 have quarter-pixel precision. Prediction of a subblock using a motion vector that happens to have integer (whole number) components is very easy: The 4x4 block of pixels from the displaced block in the previous, golden, or altref frame is simply copied into the correct position of the current macroblock's prediction buffer.
VP8が使用するモーションベクトルには、クォーターピクセル精度があります。整数（整数）コンポーネントを持つモーションベクトルを使用したサブブロックの予測は非常に簡単です。前の、金色、またはAltRefフレームの変位ブロックからのピクセルの4x4ブロックは、電流の正しい位置にコピーされますマクロブロックの予測バッファー。
Fractional displacements are conceptually and implementationally more complex. They require the inference (or synthesis) of sample values that, strictly speaking, do not exist. This is one of the most basic problems in signal processing, and readers conversant with that subject will see that the approach taken by VP8 provides a good balance of robustness, accuracy, and efficiency.
分数変位は、概念的および実装的により複雑です。厳密に言えば、存在しないサンプル値の推論（または合成）が必要です。これは信号処理における最も基本的な問題の1つであり、その主題に精通している読者は、VP8が取るアプローチが堅牢性、精度、効率の良いバランスを提供することを確認するでしょう。
Leaving the details for the implementation discussion below, the pixel interpolation is calculated by applying a kernel filter (using reasonable-precision integer math) three pixels on either side, both horizontally and vertically, of the pixel to be synthesized. The resulting 4x4 block of synthetic pixels is then copied into position exactly as in the case of integer displacements.
以下の実装ディスカッションの詳細を残して、ピクセル補間は、合成されるピクセルの水平および垂直方向の両方の側に3ピクセルのカーネルフィルター（合理的な整数数学を使用）を適用することにより計算されます。結果の合成ピクセルの4x4ブロックは、整数変位の場合とまったく同じ位置にコピーされます。
Each of the eight chroma subblocks is handled similarly. Their motion vectors are never specified explicitly; instead, the motion vector for each chroma subblock is calculated by averaging the vectors of the four Y subblocks that occupy the same area of the frame. Since chroma pixels have twice the diameter (and four times the area) of luma pixels, the calculated chroma motion vectors have 1/8-pixel resolution, but the procedure for copying or generating pixels for each subblock is essentially identical to that done in the luma plane.
8つのクロマサブブロックのそれぞれは、同様に処理されます。それらのモーションベクトルは、明示的に指定されることはありません。代わりに、各クロマサブブロックのモーションベクトルは、フレームの同じ領域を占める4つのyサブブロックのベクトルを平均することによって計算されます。クロマピクセルはルーマピクセルの直径（および面積の4倍）の2倍のため、計算されたクロマモーションベクトルは1/8ピクセルの解像度を持っていますが、各サブブロックのピクセルをコピーまたは生成する手順は、本質的に同一に同一ですルマ平面。
After all the macroblocks have been generated (predicted and corrected with the DCT/WHT residue), a filtering step (the loop filter) is applied to the entire frame. The purpose of the loop filter is to reduce blocking artifacts at the boundaries between macroblocks and between subblocks of the macroblocks. The term "loop filter" is used because this filter is part of the "coding loop"; that is, it affects the reconstructed frame buffers that are used to predict ensuing frames. This is distinguished from the postprocessing filters discussed earlier, which affect only the viewed video and do not "feed into" subsequent frames.
すべてのマクロブロックが生成された後（DCT/WHT残基で予測および修正）、フィルタリングステップ（ループフィルター）がフレーム全体に適用されます。ループフィルターの目的は、マクロブロック間とマクロブロックのサブブロック間の境界でのブロッキングアーティファクトを減らすことです。このフィルターは「コーディングループ」の一部であるため、「ループフィルター」という用語が使用されます。つまり、次のフレームを予測するために使用される再構築されたフレームバッファーに影響します。これは、前述のポストプロセスフィルターとは区別されます。これは、視聴されたビデオのみに影響を与え、後続のフレームに「フィード」しません。
Next, if signaled in the data, the current frame may replace the golden frame prediction buffer and/or the altref frame buffer.
次に、データで信号がある場合、電流フレームはゴールデンフレーム予測バッファーおよび/またはAltRefフレームバッファを置き換えることができます。
The halos of the frame buffers are next filled as specified above. Finally, at least as far as decoding is concerned, the (references to) the "current" and "last" frame buffers should be exchanged in preparation for the next frame.
フレームバッファーのハローは、上記で指定されているように次に満たされます。最後に、少なくともデコードに関する限り、「電流」と「最後の」フレームバッファー（次のフレームの準備）を交換する必要があります。
Various processes may be required (or desired) before viewing the generated frame. As discussed in the frame dimension information below, truncation and/or upscaling of the frame may be required. Some playback systems may require a different frame format (RGB, YUY2, etc.). Finally, as mentioned in the Introduction, further postprocessing or filtering of the image prior to viewing may be desired. Since the primary purpose of this document is a decoding specification, the postprocessing is not specified in this document.
生成されたフレームを表示する前に、さまざまなプロセスが必要になる（または目的）。以下のフレーム寸法情報で説明したように、フレームの切り捨ておよび/またはアップスケーリングが必要になる場合があります。一部の再生システムには、異なるフレーム形式（RGB、YUY2など）が必要になる場合があります。最後に、導入部で述べたように、表示する前に画像をさらに後処理またはフィルタリングすることが望ましい場合があります。このドキュメントの主な目的はデコード仕様であるため、このドキュメントではポストプロセスが指定されていません。
While the basic ideas of prediction and correction used by VP8 are straightforward, many of the details are quite complex. The management of probabilities is particularly elaborate. Not only do the various modes of intra-prediction and motion vector specification have associated probabilities, but they, together with the coding of DCT coefficients and motion vectors, often base these probabilities on a variety of contextual information (calculated from what has been decoded so far), as well as on explicit modification via the frame header.
VP8が使用する予測と修正の基本的なアイデアは簡単ですが、詳細の多くは非常に複雑です。確率の管理は特に精巧です。予測内および運動ベクター仕様のさまざまなモードには関連確率が関連付けられているだけでなく、DCT係数と運動ベクトルのコーディングとともに、これらの確率がさまざまなコンテキスト情報に基づいていることがよくあります（デコードされたものから計算されたものFAR）、およびフレームヘッダーを介した明示的な変更時。
The "top-level" of decoding and frame reconstruction is implemented in the reference decoder file dixie.c (Section 20.4).
デコードとフレームの再構築の「トップレベル」は、参照デコーダーファイルdixie.c（セクション20.4）に実装されています。
This concludes our summary of decoding and reconstruction; we continue by discussing the individual aspects in more depth.
これで、デコードと再構築の概要を締めくくります。私たちは、個々の側面についてもっと深く話し合うことによって続けます。
A reasonable "divide and conquer" approach to implementation of a decoder is to begin by decoding streams composed exclusively of key frames. After that works reliably, interframe handling can be added more easily than if complete functionality were attempted
デコーダーの実装に対する合理的な「分割と征服」アプローチは、キーフレームのみで構成されるストリームをデコードすることから始めることです。その後、確実に機能した後、完全な機能が試行された場合よりも、インターフレームの取り扱いを簡単に追加できます
immediately. In accordance with this, we first discuss components needed to decode key frames (most of which are also used in the decoding of interframes) and conclude with topics exclusive to interframes.
すぐに。これに従って、最初にキーフレームをデコードするために必要なコンポーネント（そのほとんどはインターフレームのデコードでも使用されています）について説明し、インターフレーム専用のトピックで締めくくります。
As the intent of this document, together with the reference decoder source code, is to specify a platform-independent procedure for the decoding and reconstruction of a VP8 video stream, many (small) algorithms must be described exactly.
このドキュメントの意図は、参照デコーダーソースコードとともに、VP8ビデオストリームのデコードと再構築のためのプラットフォームに依存しない手順を指定することであるため、多くの（小さな）アルゴリズムを正確に説明する必要があります。
Due to its near-universality, terseness, ability to easily describe calculation at specific precisions, and the fact that On2's reference VP8 decoder is written in C, these algorithm fragments are written using the C programming language, augmented with a few simple definitions below.
近くの大学、界面活性、特定の精度で計算を簡単に説明する能力、およびOn2の参照VP8デコーダーがCで記述されているという事実により、これらのアルゴリズムフラグメントは、以下のいくつかの簡単な定義で補強されたCプログラミング言語を使用して記述されます。
The standard (and best) reference for C is [Kernighan].
Cの標準（および最良の）参照は[Kernighan]です。
Many code fragments will be presented in this document. Some will be nearly identical to corresponding sections of the reference decoder; others will differ. Roughly speaking, there are three reasons for such differences:
このドキュメントでは、多くのコードフラグメントが表示されます。一部は、参照デコーダーの対応するセクションとほぼ同じです。他の人は異なります。大事に言えば、そのような違いには3つの理由があります。
1. For reasons of efficiency, the reference decoder version may be less obvious.
1. 効率の理由から、参照デコーダーバージョンの明白なものはそれほど明白ではない場合があります。
2. The reference decoder often uses large data structures to maintain context that need not be described or used here.
2. 参照デコーダーは、多くの場合、大きなデータ構造を使用して、ここで説明または使用する必要がないコンテキストを維持します。
3. The authors of this document felt that a different expression of the same algorithm might facilitate exposition.
3. この文書の著者は、同じアルゴリズムの異なる式が博覧会を促進する可能性があると感じました。
Regardless of the chosen presentation, the calculation effected by any of the algorithms described here is identical to that effected by the corresponding portion of the reference decoder.
選択したプレゼンテーションに関係なく、ここで説明するアルゴリズムのいずれかによって影響される計算は、参照デコーダーの対応する部分によって影響されるものと同一です。
All VP8 decoding algorithms use integer math. To facilitate specification of arithmetic precision, we define the following types.
すべてのVP8デコードアルゴリズムは整数数学を使用します。算術精度の仕様を容易にするために、次のタイプを定義します。
---- Begin code block --------------------------------------
typedef signed char int8; /* signed int exactly 8 bits wide */
typedef unsigned char uint8; /* unsigned "" */
typedef short int16; /* signed int exactly 16 bits wide */
typedef unsigned int16 uint16; /* unsigned "" */
/* int32 is a signed integer type at least 32 bits wide */
typedef long int32; /* guaranteed to work on all systems */
typedef int int32; /* will be more efficient on some systems */
typedef unsigned int32 uint32;
typedef unsigned int32 uint32;
/* unsigned integer type, at least 16 bits wide, whose exact size
is most convenient to whatever processor we are using */
typedef unsigned int uint;
typedef unsigned int uint;
/* While pixels themselves are 8-bit unsigned integers,
pixel arithmetic often occurs at 16- or 32-bit precision and
the results need to be "saturated" or clamped to an 8-bit
range. */
typedef uint8 Pixel;
typedef uint8 pixel;
Pixel clamp255(int32 v) { return v < 0? 0 : (v < 255? v : 255);}
/* As is elaborated in the discussion of the bool_decoder below,
VP8 represents probabilities as unsigned 8-bit numbers. */
typedef uint8 Prob;
typedef uint8 prob;
---- End code block ----------------------------------------
We occasionally need to discuss mathematical functions involving honest-to-goodness "infinite precision" real numbers. The DCT is first described via the cosine function cos; the ratio of the lengths of the circumference and diameter of a circle is denoted pi; at one point, we take a (base 1/2) logarithm, denoted log; and pow(x, y) denotes x raised to the power y. If x = 2 and y is a small non-negative integer, pow(2, y) may be expressed in C as 1 << y.
時折、誠実さの「無限の精度」の実数を含む数学的機能について議論する必要があります。DCTは、COSINE関数COSを介して最初に説明されています。円周囲の長さと円の直径の比は、Piと表されます。ある時点で、（ベース1/2）の対数を撮影します。Pow（x、y）は、xをパワーyに上げたxを示します。x = 2およびyが小さな非陰性整数である場合、c（2、y）はcで1 << yとして発現できます。
Finally, we sometimes need to divide signed integers by powers of two; that is, we occasionally right-shift signed numbers. The behavior of such shifts (i.e., the propagation of the sign bit) is, perhaps surprisingly, not defined by the C language itself and is left up to individual compilers. Because of the utility of this frequently needed operation, it is at least arguable that it should be defined by the language (to naturally propagate the sign bit) and, at a minimum, should be correctly implemented by any reasonable compiler. In the interest of strict portability, we attempt to call attention to these shifts when they arise.
最後に、署名された整数を2つのパワーで分割する必要がある場合があります。つまり、時々右に署名された数字です。そのようなシフトの動作（つまり、サインビットの伝播）は、おそらく驚くべきことに、C言語自体によって定義されておらず、個々のコンパイラに任されています。この頻繁に必要な操作の有用性のため、言語によって定義する必要があることは少なくとも議論の余地があります（サインビットを自然に伝播するために）、少なくとも合理的なコンパイラによって正しく実装される必要があります。厳格な携帯性のために、これらのシフトが発生したときに注意を喚起しようとします。
As discussed in the overview above, essentially the entire VP8 data stream is encoded using a boolean entropy coder.
上記の概要で説明したように、基本的にVP8データストリーム全体がブールエントロピーコーダーを使用してエンコードされます。
An understanding of the bool_decoder is critical to the implementation of a VP8 decompressor, so we discuss the bool_decoder in detail. It is easier to comprehend the bool_decoder in conjunction with the bool_encoder used by the compressor to write the compressed data partitions.
BOOL_DECODERの理解は、VP8減圧器の実装にとって重要であるため、BOOL_DECODERについて詳しく説明します。圧縮データパーティションを書き込むためにコンプレッサーが使用するbool_encoderと組み合わせてbool_decoderを理解する方が簡単です。
The bool_encoder encodes (and the bool_decoder decodes) one bool (zero-or-one boolean value) at a time. Its purpose is to losslessly compress a sequence of bools for which the probability of their being zero or one can be well-estimated (via constant or previously coded information) at the time they are written, using identical corresponding probabilities at the time they are read.
bool_encoderは、一度に1つのブール（ゼロまたは1つのブール値）をエンコードします（およびbool_decoderデコード）。その目的は、ゼロまたは1つが書かれている時点で（一定または以前にコード化された情報を介して）ゼロまたは1つを保護することができる一連のブールを損なうことです。。
As the reader is probably aware, if a bool is much more likely to be zero than one (for instance), it can, on average, be faithfully encoded using much less than one bit per value. The bool_encoder exploits this.
読者はおそらく認識しているように、ブールが（たとえば）（たとえば）よりもはるかにゼロである可能性がはるかに高い場合、平均して、値ごとに1ビット未満を使用して忠実にエンコードできます。bool_encoderはこれを悪用します。
In the 1940s, [Shannon] proved that there is a lower bound for the average datarate of a faithful encoding of a sequence of bools (whose probability distributions are known and are independent of each other) and also that there are encoding algorithms that approximate this lower bound as closely as one wishes.
1940年代に、[シャノン]は、一連のブールの忠実なエンコードの平均データの平均データ（確率分布が既知であり、互いに独立している）の下限があることを証明し、またこれに近似するエンコードアルゴリズムがあることも証明しました。希望するほど密接に下限。
If we encode a sequence of bools whose probability of being zero is p (and whose probability of being 1 is 1-p), the lowest possible datarate per value is
ゼロである確率がpである（および1である確率が1-p）ブールのシーケンスをエンコードすると、値ごとの最低のデータレー酸塩は値です。
plog(p) + (1-p)log(1-p);
taking the logarithms to the base 1/2 expresses the datarate in bits/ value.
対数をベース1/2に使用すると、データレートがビット/値で表されます。
We give two simple examples. At one extreme, if p = 1/2, then log(p) = log(1-p) = 1, and the lowest possible datarate per bool is 1/2 + 1/2 = 1; that is, we cannot do any better than simply literally writing out bits. At another extreme, if p is very small, say p = 1/1024, then log(p)=10, log(1-p) is roughly .0014, and the lowest possible datarate is approximately 10/1024 + .0014, roughly 1/100 of a bit per bool.
2つの簡単な例を示します。1つの極端で、p = 1/2の場合、log（p）= log（1-p）= 1、およびブールあたりの可能な最低のデータレートは1/2 1/2 = 1です。つまり、単に文字通りビットを書き出すよりも良いことはできません。別の極端では、pが非常に小さい場合、たとえばp = 1/1024、log（p）= 10、log（1-p）は約.0014であり、可能な限り低いデータラートは約10/1024 .0014で、おおよそ約10/1024 .0014です。ブールごとに1/100。
Because most of the bools in the VP8 datastream have zero-probabilities nowhere near 1/2, the compression provided by the bool_encoder is critical to the performance of VP8.
VP8 DataStreamのブールのほとんどは、1/2近くにゼロプロビリティを持っているため、bool_encoderによって提供される圧縮はVP8のパフォーマンスにとって重要です。
The boolean coder used by VP8 is a variant of an arithmetic coder. An excellent discussion of arithmetic coding (and other lossless compression techniques) can be found in [Bell].
VP8が使用するブールコーダーは、算術コーダーのバリアントです。算術コーディング（およびその他のロスレス圧縮技術）の優れた議論は、[ベル]にあります。
The basic idea used by the boolean coder is to consider the entire data stream (either of the partitions in our case) as the binary expansion of a single number x with 0 <= x < 1. The bits (or bytes) in x are of course written from high to low order, and if b[j] (B[j]) is the j^(th) bit (byte) in the partition, the value x is simply the sum (starting with j = 1) of pow(2, -j) * b[j] or pow(256, -j) * B[j].
ブールコーダーが使用する基本的なアイデアは、データストリーム全体（私たちの場合のパーティションのいずれか）を0 <= x <1の単一の数値xのバイナリ拡張と見なすことです。xのビット（またはバイト）はです。もちろん、高度から低いものから低いもの、そしてb [j]（b [j]）がパーティションのj^（th）ビット（byte）である場合、値xは単に合計です（j = 1で始まる）Pow（2、-J） * B [J]またはPOW（256、-J） * B [J]。
Before the first bool is coded, all values of x are possible.
最初のブールがコーディングされる前に、xのすべての値が可能です。
The coding of each bool restricts the possible values of x in proportion to the probability of what is coded. If p1 is the probability of the first bool being zero and a zero is coded, the range of possible values of x is restricted to 0 <= x < p1. If a one is coded, the range becomes p1 <= x < 1.
各ブールのコーディングは、コード化されたものの確率に比例してxの可能な値を制限します。P1が最初のブールがゼロであり、ゼロがコード化される確率である場合、xの可能な値の範囲は0 <= x <p1に制限されます。1つがコーディングされている場合、範囲はp1 <= x <1になります。
The coding continues by repeating the same idea. At every stage, there is an interval a <= x < b of possible values of x. If p is the probability of a zero being coded at this stage and a zero is coded, the interval becomes a <= x < a + (p(b-a)). If a one is coded, the possible values of x are restricted to a + (p(b-a)) <= x < b.
コーディングは、同じアイデアを繰り返すことで継続します。すべての段階で、xの可能な値の間隔A <= x <bがあります。pがこの段階でゼロがコーディングされ、ゼロがコーディングされる確率である場合、間隔はa <= x <a（p（b-a））になります。1がコーディングされている場合、xの可能な値はa（p（b-a））<= x <bに制限されます。
Assuming that only finitely many values are to be coded, after the encoder has received the last bool, it can write as its output any value x that lies in the final interval. VP8 simply writes the left endpoint of the final interval. Consequently, the output it would make if encoding were to stop at any time either increases or stays the same as each bool is encoded.
エンコーダーが最後のブールを受信した後、有限数の値のみがコーディングされると仮定すると、最終間隔にある値xを出力すると書き込むことができます。VP8は、最終間隔の左のエンドポイントを単純に書き込むだけです。したがって、エンコードがいつでも停止する場合、各ブールがエンコードされるのと同じように停止する場合、それが行う出力が生じます。
Decoding parallels encoding. The decoder is presented with the number x, which has only the initial restriction 0 <= x < 1. To decode the first bool, the decoder is given the first probability p1. If x < p1, a zero is decoded; if x >= p1, a one is decoded. In either case, the new restriction on x -- that is, the interval of possible values of x -- is remembered.
デコードはエンコードに似ています。デコーダーには、最初の制限0 <= x <1のみがある数値xで表示されます。最初のブールをデコードするには、デコーダーに最初の確率p1が与えられます。x <p1の場合、ゼロがデコードされます。x> = p1の場合、1つはデコードされます。どちらの場合でも、xの新しい制限、つまりxの可能な値の間隔 - が記憶されています。
Decoding continues in exactly the same way: If a <= x < b is the current interval and we are to decode a bool with zero-probability p, we return a zero if a <= x < a + (p(b-a)) and a one if a + (p(b-a)) <= x < b. In either case, the new restriction is remembered in preparation for decoding the next bool.
デコードはまったく同じ方法で継続します。A<= x <bが現在の間隔であり、ゼロパロビーズ性pでブールをデコードする場合、a <= x <a（p（b-a））とゼロを返し、a（p（b-a））<= x <bの場合どちらの場合でも、次のブールのデコードに備えて新しい制限が記憶されています。
The process outlined above uses real numbers of infinite precision to express the probabilities and ranges. It is true that, if one could actualize this process and coded a large number of bools whose supplied probabilities matched their value distributions, the datarate achieved would approach the theoretical minimum as the number of bools encoded increased.
上記のプロセスでは、実数の無限の精度を使用して、確率と範囲を表現します。このプロセスを実現し、付属の確率が価値分布と一致する多数のブールをコーディングできれば、達成されたデータは、エンコードされたブールの数が増加するにつれて理論的最小に近づくでしょう。
Unfortunately, computers operate at finite precision, and an approximation to the theoretically perfect process described above is necessary. Such approximation increases the datarate but, at quite moderate precision and for a wide variety of data sets, this increase is negligible.
残念ながら、コンピューターは有限精度で動作し、上記の理論的に完全なプロセスに近似することが必要です。このような近似はデータレートを増加させますが、非常に中程度の精度で、さまざまなデータセットの場合、この増加は無視できます。
The only conceptual limitations are, first, that coder probabilities must be expressed at finite precision and, second, that the decoder be able to detect each individual modification to the value interval via examination of a fixed amount of input. As a practical matter, many of the implementation details stem from the fact that the coder can function using only a small "window" to incrementally read or write the arbitrarily precise number x.
唯一の概念的な制限は、第一に、コーダーの確率を有限精度で表現する必要があり、次に、デコーダーが固定量の入力を調べて各個々の変更を値間隔に検出できることです。実用的な問題として、実装の詳細の多くは、コーダーが小さな「ウィンドウ」のみを使用して機能して、任意の正確な数字xを段階的に読み書きできるという事実に由来しています。
VP8's boolean coder works with 8-bit probabilities p. The range of such p is 0 <= p <= 255; the actual probability represented by p is p/256. Also, the coder is designed so that decoding of a bool requires no more than an 8-bit comparison, and so that the state of both the encoder and decoder can be easily represented using a small number of unsigned 16-bit integers.
VP8のブールコーダーは、8ビット確率で動作します。そのようなpの範囲は0 <= p <= 255です。pで表される実際の確率はp/256です。また、コーダーは、ブールのデコードに8ビットの比較を必要とするように設計されているため、エンコーダーとデコーダーの両方の状態を少数の署名されていない16ビット整数を使用して簡単に表現できます。
The details are most easily understood if we first describe the algorithm using bit-at-a-time input and output. Aside from the ability to maintain a position in this bitstream and write/read bits, the encoder also needs the ability to add 1 to the bits already output; after writing n bits, adding 1 to the existing output is the same thing as adding pow(2, -n) to x.
詳細は、最初に時間の入力と出力を使用してアルゴリズムを説明する場合に最も簡単に理解できます。このビットストリームでの位置を維持し、ビットを書き込み/読み取る機能は別として、エンコーダーは、すでに出力をビットに追加する機能も必要です。nビットを書き込んだ後、既存の出力に1を追加することは、pow（2、-n）をxに追加することと同じです。
Together with the bit position, the encoder must maintain two unsigned 8-bit numbers, which we call "bottom" and "range". Writing w for the n bits already written and S = pow(2, - n - 8) for the scale of the current bit position one byte out, we have the following constraint on all future values v of w (including the final value v = x):
ビット位置とともに、エンコーダーは「ボトム」と「範囲」と呼ばれる2つの署名されていない8ビット番号を維持する必要があります。既に書かれたnビットとs = pow（2、-n -8）のwを書き込む現在のビット位置1バイトのスケールについては、wのすべての将来の値v（最終値vを含むすべての将来の値vに次の制約があります= x）：
w + ( S * bottom ) <= v < w + ( S * ( bottom + range ) )
Thus, appending bottom to the already-written bits w gives the left endpoint of the interval of possible values, appending bottom + range gives the right endpoint, and range itself (scaled to the current output position) is the length of the interval.
したがって、既に書かれたビットwに底部を追加すると、可能な値の間隔の左のエンドポイントが得られ、底部の範囲が右のエンドポイントを与え、範囲自体（現在の出力位置にスケーリング）が間隔の長さです。
So that our probabilistic encodings are reasonably accurate, we do not let range vary by more than a factor of two: It stays within the bounds 128 <= range <= 255.
確率的エンコーディングが合理的に正確になるように、範囲を2倍以上変化させることはありません。
The process for encoding a boolean value val whose probability of being zero is prob / 256 -- and whose probability of being one is ( 256 - prob ) / 256 -- with 1 <= prob <= 255 is as follows.
ゼロである確率がprob / 256であり、1つである確率が（256 -prob） / 256であるというブール値Valをエンコードするプロセスは、1 <= prob <= 255で次のとおりです。
Using an unsigned 16-bit multiply followed by an unsigned right shift, we calculate an unsigned 8-bit split value:
符号なしの16ビット乗算に続いて署名されていない右シフトを使用して、署名されていない8ビットスプリット値を計算します。
split = 1 + (((range - 1) * probability)]] >> 8)
split is approximately ( prob / 256 ) * range and lies within the bounds 1 <= split <= range - 1. These bounds ensure the correctness of the decoding procedure described below.
スプリットは約（prob / 256） *範囲であり、境界1 <= split <=範囲-1。これらの境界は、以下で説明するデコード手順の正確性を保証します。
If the incoming boolean val to be encoded is false, we leave the left interval endpoint bottom alone and reduce range, replacing it by split. If the incoming val is true, we move up the left endpoint to bottom + split, propagating any carry to the already-written value w (this is where we need the ability to add 1 to w), and reduce range to range - split.
エンコードされる入っているブールバルがfalseである場合、左の間隔エンドポイントの底部のみを残して範囲を減らして、分割に置き換えます。着信バルが真の場合、左のエンドポイントを上に移動して、キャリーを既に書かれた値wに伝播します（これは1からwを追加する機能が必要です）。
Regardless of the value encoded, range has been reduced and now has the bounds 1 <= range <= 254. If range < 128, the encoder doubles it and shifts the high-order bit out of bottom to the output as it also doubles bottom, repeating this process one bit at a time until 128 <= range <= 255. Once this is completed, the encoder is ready to accept another bool, maintaining the constraints described above.
エンコードされた値に関係なく、範囲は削減され、現在は範囲1 <=範囲<= 254になりました。、このプロセスを一度に1つずつ繰り返し、128 <=範囲<= 255になります。これが完了すると、エンコーダは別のブールを受け入れる準備ができており、上記の制約を維持します。
After encoding the last bool, the partition may be completed by appending bottom to the bitstream.
最後のブールをエンコードした後、パーティションはビットストリームに底部を追加することで完了することができます。
The decoder mimics the state of the encoder. It maintains, together with an input bit position, two unsigned 8-bit numbers, a range identical to that maintained by the encoder and a value. Decoding one bool at a time, the decoder (in effect) tracks the same left interval endpoint as does the encoder and subtracts it from the remaining input. Appending the unread portion of the bitstream to the 8-bit value gives the difference between the actual value encoded and the known left endpoint.
デコーダーはエンコーダーの状態を模倣します。入力ビット位置とともに、2つの署名されていない8ビット数字が維持されます。これは、エンコーダーと値によって維持される範囲と同じ範囲です。一度に1つのブールを解読すると、デコーダー（効果的）は、エンコーダと同じ左の間隔エンドポイントを追跡し、残りの入力から減算します。ビットストリームの未読部分を8ビット値に追加すると、実際の値エンコードされた値と既知の左端ポイントの差が得られます。
The decoder is initialized by setting range = 255 and reading the first 16 input bits into value. The decoder maintains range and calculates split in exactly the same way as does the encoder.
デコーダーは、範囲= 255を設定し、最初の16の入力ビットを値に読み取ることによって初期化されます。デコーダーは範囲を維持し、エンコーダーとまったく同じ方法で分割されます。
To decode a bool, it compares value to split; if value < split, the bool is zero, and range is replaced with split. If value >= split, the bool is one, range is replaced with range - split, and value is replaced with value - split.
ブールをデコードすると、値を分割と比較します。値<分割の場合、ブールはゼロであり、範囲は分割に置き換えられます。値> =分割の場合、ブールは1、範囲は範囲に置き換えられ、値は値 - 分割に置き換えられます。
Again, range is doubled one bit at a time until it is at least 128. The value is doubled in parallel, shifting a new input bit into the bottom each time.
繰り返しますが、範囲は少なくとも128になるまで一度に1つずつ2倍になります。値は並行して2倍になり、毎回新しい入力ビットが底にシフトされます。
Writing Value for value together with the unread input bits and Range for range extended indefinitely on the right by zeros, the condition Value < Range is maintained at all times by the decoder. In particular, the bits shifted out of value as it is doubled are always zero.
値の書き込み値と未読の入力ビットと範囲の範囲の書き込みゼロは、ゼロによって無期限に拡張され、条件値<範囲は常にデコーダーによって維持されます。特に、2倍になっているため、ビットは常にゼロになっています。
The C code below gives complete implementations of the encoder and decoder described above. While they are logically identical to the "bit-at-a-time" versions, they internally buffer a couple of extra bytes of the bitstream. This allows I/O to be done (more practically) a byte at a time and drastically reduces the number of carries the encoder has to propagate into the already-written data.
以下のCコードは、上記のエンコーダーとデコーダーの完全な実装を示しています。それらは論理的に「一時的な」バージョンと同一ですが、ビットストリームのいくつかの追加バイトを内部的にバッファリングします。これにより、I/Oを（より実際に）一度にバイトを実行することができ、エンコーダーが既に書かれたデータに伝播するキャリーの数を大幅に削減できます。
Another (logically equivalent) implementation may be found in the reference decoder file bool_decoder.h (Section 20.2).
別の（論理的に同等の）実装は、参照デコーダーファイルbool_decoder.h（セクション20.2）に記載されています。
---- Begin code block --------------------------------------
/* Encoder first */
typedef struct {
uint8 *output; /* ptr to next byte to be written */
uint32 range; /* 128 <= range <= 255 */
uint32 bottom; /* minimum value of remaining output */
int bit_count; /* # of shifts before an output byte
is available */
} bool_encoder;
/* Must set initial state of encoder before writing any bools. */
void init_bool_encoder(bool_encoder *e, uint8 *start_partition)
{
e->output = start_partition;
e->range = 255;
e->bottom = 0;
e->bit_count = 24;
}
/* Encoding very rarely produces a carry that must be propagated
to the already-written output. The arithmetic guarantees that
the propagation will never go beyond the beginning of the
output. Put another way, the encoded value x is always less
than one. */
void add_one_to_output(uint8 *q)
{
while (*--q == 255)
*q = 0;
++*q;
}
/* Main function writes a bool_value whose probability of being
zero is (expected to be) prob/256. */
void write_bool(bool_encoder *e, Prob prob, int bool_value)
{
/* split is approximately (range * prob) / 256 and,
crucially, is strictly bigger than zero and strictly
smaller than range */
uint32 split = 1 + (((e->range - 1) * prob) >> 8);
if (bool_value) {
e->bottom += split; /* move up bottom of interval */
e->range -= split; /* with corresponding decrease in range */
} else
e->range = split; /* decrease range, leaving bottom alone */
while (e->range < 128)
{
e->range <<= 1;
if (e->bottom & (1 << 31)) /* detect carry */
add_one_to_output(e->output);
e->bottom <<= 1; /* before shifting bottom */
if (!--e->bit_count) { /* write out high byte of bottom ... */
*e->output++ = (uint8) (e->bottom >> 24);
e->bottom &= (1 << 24) - 1; /* ... keeping low 3 bytes */
e->bit_count = 8; /* 8 shifts until next output */
}
}
}
/* Call this function (exactly once) after encoding the last
bool value for the partition being written */
void flush_bool_encoder(bool_encoder *e)
{
int c = e->bit_count;
uint32 v = e->bottom;
if (v & (1 << (32 - c))) /* propagate (unlikely) carry */
add_one_to_output(e->output);
v <<= c & 7; /* before shifting remaining output */
c >>= 3; /* to top of internal buffer */
while (--c >= 0)
v <<= 8;
c = 4;
while (--c >= 0) { /* write remaining data, possibly padded */
*e->output++ = (uint8) (v >> 24);
v <<= 8;
}
}
/* Decoder state exactly parallels that of the encoder.
"value", together with the remaining input, equals the
complete encoded number x less the left endpoint of the
current coding interval. */
typedef struct {
uint8 *input; /* pointer to next compressed data byte */
uint32 range; /* always identical to encoder's range */
uint32 value; /* contains at least 8 significant bits */
int bit_count; /* # of bits shifted out of
value, at most 7 */
} bool_decoder;
/* Call this function before reading any bools from the
partition. */
void init_bool_decoder(bool_decoder *d, uint8 *start_partition)
{
{
int i = 0;
d->value = 0; /* value = first 2 input bytes */
while (++i <= 2)
d->value = (d->value << 8) | *start_partition++;
}
d->input = start_partition; /* ptr to next byte to be read */
d->range = 255; /* initial range is full */
d->bit_count = 0; /* have not yet shifted out any bits */
}
/* Main function reads a bool encoded at probability prob/256,
which of course must agree with the probability used when the
bool was written. */
int read_bool(bool_decoder *d, Prob prob)
{
/* range and split are identical to the corresponding values
used by the encoder when this bool was written */
uint32 split = 1 + (((d->range - 1) * prob) >> 8);
uint32 SPLIT = split << 8;
int retval; /* will be 0 or 1 */
if (d->value >= SPLIT) { /* encoded a one */
retval = 1;
d->range -= split; /* reduce range */
d->value -= SPLIT; /* subtract off left endpoint of interval */
} else { /* encoded a zero */
retval = 0;
d->range = split; /* reduce range, no change in left endpoint */
}
while (d->range < 128) { /* shift out irrelevant value bits */
d->value <<= 1;
d->range <<= 1;
if (++d->bit_count == 8) { /* shift in new bits 8 at a time */
d->bit_count = 0;
d->value |= *d->input++;
}
}
return retval;
}
/* Convenience function reads a "literal", that is, a "num_bits"-
wide unsigned value whose bits come high- to low-order, with
each bit encoded at probability 128 (i.e., 1/2). */
uint32 read_literal(bool_decoder *d, int num_bits)
{
uint32 v = 0;
while (num_bits--)
v = (v << 1) + read_bool(d, 128);
return v;
}
/* Variant reads a signed number */
int32 read_signed_literal(bool_decoder *d, int num_bits)
{
int32 v = 0;
if (!num_bits)
return 0;
if (read_bool(d, 128))
v = -1;
while (--num_bits)
v = (v << 1) + read_bool(d, 128);
return v;
}
---- End code block ----------------------------------------
At the lowest level, VP8's compressed data is simply a sequence of probabilistically encoded bools. Most of this data is composed of (slightly) larger semantic units fashioned from bools, which we describe here.
最低レベルでは、VP8の圧縮データは、単に確率的にエンコードされたブールのシーケンスです。このデータのほとんどは、ここで説明するブールから作られた（わずかに）大きなセマンティックユニットで構成されています。
We sometimes use these descriptions in C expressions within data format specifications. In this context, they refer to the return value of a call to an appropriate bool_decoder d, reading (as always) from its current reference point.
これらの説明は、データ形式の仕様内でC式でc式で使用することがあります。この文脈では、適切なbool_decoder Dへの呼び出しの返品値を参照し、現在の基準点から（いつものように）読み取ります。
+--------------+-------+--------------------------------------------+
| Call | Alt. | Return |
+--------------+-------+--------------------------------------------+
| Bool(p) | B(p) | Bool with probability p/256 of being 0. |
| | | Return value of read_bool(d, p). |
| | | |
| Flag | F | A one-bit flag (same thing as a B(128) or |
| | | an L(1)). Abbreviated F. Return value of |
| | | read_bool(d, 128). |
| | | |
| Lit(n) | L(n) | Unsigned n-bit number encoded as n flags |
| | | (a "literal"). Abbreviated L(n). The |
| | | bits are read from high to low order. |
| | | Return value of read_literal(d, n). |
| | | |
| SignedLit(n) | | Signed n-bit number encoded similarly to |
| | | an L(n). Return value of |
| | | read_signed_literal(d, n). These are |
| | | rare. |
| | | |
| P(8) | | An 8-bit probability. No different from |
| | | an L(8), but we sometimes use this |
| | | notation to emphasize that a probability |
| | | is being coded. |
| | | |
| P(7) | | A 7-bit specification of an 8-bit |
| | | probability. Coded as an L(7) number x; |
| | | the resulting 8-bit probability is x ? x |
| | | << 1 : 1. |
| | | |
| F? X | | A flag that, if true, is followed by a |
| | | piece of data X. |
| | | |
| F? X:Y | | A flag that, if true, is followed by X |
| | | and, if false, is followed by Y. Also |
| | | used to express a value where Y is an |
| | | implicit default (not encoded in the data |
| | | stream), as in F? P(8):255, which |
| | | expresses an optional probability: If the |
| | | flag is true, the probability is specified |
| | | as an 8-bit literal, while if the flag is |
| | | false, the probability defaults to 255. |
| | | |
| B(p)? X | B(p)? | Variants of the above using a boolean |
| | X:Y | indicator whose probability is not |
| | | necessarily 128. |
| | | |
| T | | Tree-encoded value from small alphabet. |
+--------------+-------+--------------------------------------------+
The last type requires elaboration. We often wish to encode something whose value is restricted to a small number of possibilities (the alphabet).
最後のタイプでは、詳細が必要です。多くの場合、価値が少数の可能性（アルファベット）に限定されているものをエンコードしたいと考えています。
This is done by representing the alphabet as the leaves of a small binary tree. The (non-leaf) nodes of the tree have associated probabilities p and correspond to calls to read_bool(d, p). We think of a zero as choosing the left branch below the node and a one as choosing the right branch.
これは、アルファベットを小さなバイナリツリーの葉として表すことによって行われます。ツリーの（葉以外の）ノードは、関連する確率pを持ち、read_bool（d、p）への呼び出しに対応しています。ゼロは、ノードの下の左のブランチを選択し、右のブランチを選択するものとして考えています。
Thus, every value (leaf) whose tree depth is x is decoded after exactly x calls to read_bool.
したがって、Xがxがxであるすべての値（葉）は、read_boolを正確にx呼び出した後にデコードされます。
A tree representing an encoding of an alphabet of n possible values always contains n-1 non-leaf nodes, regardless of its shape (this is easily seen by induction on n).
n可能な値のアルファベットのエンコードを表すツリーには、その形状に関係なく、常にn-1非葉のノードが含まれます（これはnの誘導によって簡単に見られます）。
There are many ways that a given alphabet can be so represented. The choice of tree has little impact on datarate but does affect decoder performance. The trees used by VP8 are chosen to (on average) minimize the number of calls to read_bool. This amounts to shaping the tree so that values that are more probable have smaller tree depth than do values that are less probable.
特定のアルファベットをそのように表現できる多くの方法があります。ツリーの選択はデータの影響はほとんどありませんが、デコーダーの性能に影響します。VP8が使用するツリーは、（平均して）read_boolへの呼び出しの数を最小限に抑えるように選択されます。これは、ツリーを形作ることになり、より可能性の高い値が、それほど低い値よりも木の深さが小さくなります。
Readers familiar with Huffman coding will notice that, given an alphabet together with probabilities for each value, the associated Huffman tree minimizes the expected number of calls to read_bool.
Huffman Codingに精通している読者は、各値の確率とアルファベットを考えると、関連するHuffman Treeがread_boolへの呼び出し数を最小限に抑えることに気付くでしょう。
Such readers will also realize that the coding method described here never results in higher datarates than does the Huffman method and, indeed, often results in much lower datarates. Huffman coding is, in fact, nothing more than a special case of this method in which each node probability is fixed at 128 (i.e., 1/2).
このような読者はまた、ここで説明するコーディング方法は、Huffmanメソッドよりも高いデータレートを得ることはないことを認識し、実際にはしばしばはるかに低いデータレートをもたらすことになります。実際、ハフマンコーディングは、各ノードの確率が128（つまり1/2）に固定されているこの方法の特別なケースにすぎません。
We give a suggested implementation of a tree data structure followed by a couple of actual examples of its usage by VP8.
ツリーデータ構造の提案された実装に続いて、VP8による使用の実際の例がいくつかあります。
It is most convenient to represent the values using small positive integers, typically an enum counting up from zero. The largest alphabet (used to code DCT coefficients, described in Section 13) that is tree-coded by VP8 has only 12 values. The tree for this alphabet adds 11 interior nodes and so has a total of 23 positions. Thus, an 8-bit number easily accommodates both a tree position and a return value.
小さな正の整数を使用して値を表すことが最も便利です。通常、ゼロからカウントアップする列挙です。VP8によってツリーコード化された最大のアルファベット（セクション13で説明されているDCT係数をコードするために使用）には、12の値しかありません。このアルファベットのツリーには、11の内部ノードが追加されているため、合計23のポジションがあります。したがって、8ビット番号は、ツリーの位置と戻り値の両方に簡単に対応できます。
A tree may then be compactly represented as an array of (pairs of) 8-bit integers. Each (even) array index corresponds to an interior node of the tree; the 0th index of course corresponds to the root of the tree. The array entries come in pairs corresponding to the left (0) and right (1) branches of the subtree below the interior node. We use the convention that a positive (even) branch entry is the index of a deeper interior node, while a nonpositive entry v corresponds to a leaf whose value is -v.
ツリーは、8ビット整数の（ペアの）配列としてコンパクトに表される場合があります。各（均一な）配列インデックスは、ツリーの内部ノードに対応します。コースの0番目のインデックスは、ツリーのルートに対応します。配列エントリは、内部ノードの下のサブツリーの左（0）と右（1）の分岐に対応するペアで提供されます。正の（均一な）ブランチエントリがより深い内部ノードのインデックスであるという規則を使用しますが、非陽性エントリvは値が-vの葉に対応します。
The node probabilities associated to a tree-coded value are stored in an array whose indices are half the indices of the corresponding tree positions. The length of the probability array is one less than the size of the alphabet.
ツリーコードされた値に関連付けられたノード確率は、対応するツリー位置のインデックスの半分のインデックスがある配列に保存されます。確率アレイの長さは、アルファベットのサイズよりも1つ少ないです。
Here is C code implementing the foregoing. The advantages of our data structure should be noted. Aside from the smallness of the structure itself, the tree-directed reading algorithm is essentially a single line of code.
以下は、前述を実装するCコードです。データ構造の利点に注意する必要があります。構造自体の小ささは別として、ツリー指向の読み取りアルゴリズムは、本質的にコードの単一行です。
---- Begin code block --------------------------------------
/* A tree specification is simply an array of 8-bit integers. */
typedef int8 tree_index; typedef const tree_index Tree[];
typedef int8 tree_index;typedef const tree_indexツリー[];
/* Read and return a tree-coded value at the current decoder
position. */
int treed_read(
bool_decoder * const d, /* bool_decoder always returns a 0 or 1 */
Tree t, /* tree specification */
const Prob p[] /* corresponding interior node probabilities */
) {
register tree_index i = 0; /* begin at root */
/* Descend tree until leaf is reached */
while ((i = t[ i + read_bool(d, p[i>>1])]) > 0) {}
return -i; /* return value is negation of nonpositive index */
}
---- End code block ----------------------------------------
Tree-based decoding is implemented in the reference decoder file bool_decoder.h (Section 20.2).
ツリーベースのデコードは、参照デコーダーファイルbool_decoder.h（セクション20.2）に実装されています。
As a multi-part example, without getting too far into the semantics of macroblock decoding (which is of course taken up below), we look at the "mode" coding for intra-predicted macroblocks.
マルチパートの例として、マクロブロックデコードのセマンティクス（もちろん以下で取り上げられています）に行き過ぎずに、予測されているマクロブロックの「モード」コーディングを調べます。
It so happens that, because of a difference in statistics, the Y (or luma) mode encoding uses two different trees: one for key frames and another for interframes. This is the only instance in VP8 of the same dataset being coded by different trees under different circumstances. The UV (or chroma) modes are a proper subset of the Y modes and, as such, have their own decoding tree.
統計の違いのために、Y（またはLUMA）モードをエンコードすると、2つの異なるツリーが使用されます。1つはキーフレーム用、もう1つはインターフレーム用です。これは、異なる状況下で異なるツリーによってコーディングされている同じデータセットのVP8の唯一のインスタンスです。UV（またはChroma）モードはYモードの適切なサブセットであり、そのため独自のデコードツリーがあります。
---- Begin code block --------------------------------------
typedef enum
{
DC_PRED, /* predict DC using row above and column to the left */
V_PRED, /* predict rows using row above */
H_PRED, /* predict columns using column to the left */
TM_PRED, /* propagate second differences a la "True Motion" */
B_PRED, /* each Y subblock is independently predicted */
num_uv_modes = B_PRED, /* first four modes apply to chroma */
num_ymodes /* all modes apply to luma */
}
intra_mbmode;
/* The aforementioned trees together with the implied codings as
comments.
Actual (i.e., positive) indices are always even.
Value (i.e., nonpositive) indices are arbitrary. */
const tree_index ymode_tree [2 * (num_ymodes - 1)] =
{
-DC_PRED, 2, /* root: DC_PRED = "0", "1" subtree */
4, 6, /* "1" subtree has 2 descendant subtrees */
-V_PRED, -H_PRED, /* "10" subtree: V_PRED = "100",
H_PRED = "101" */
-TM_PRED, -B_PRED /* "11" subtree: TM_PRED = "110",
B_PRED = "111" */
};
const tree_index kf_ymode_tree [2 * (num_ymodes - 1)] =
{
-B_PRED, 2, /* root: B_PRED = "0", "1" subtree */
4, 6, /* "1" subtree has 2 descendant subtrees */
-DC_PRED, -V_PRED, /* "10" subtree: DC_PRED = "100",
V_PRED = "101" */
-H_PRED, -TM_PRED /* "11" subtree: H_PRED = "110",
TM_PRED = "111" */
};
const tree_index uv_mode_tree [2 * (num_uv_modes - 1)] =
{
-DC_PRED, 2, /* root: DC_PRED = "0", "1" subtree */
-V_PRED, 4, /* "1" subtree: V_PRED = "10",
"11" subtree */
-H_PRED, -TM_PRED /* "11" subtree: H_PRED = "110",
TM_PRED = "111" */
};
/* Given a bool_decoder d, a Y mode might be decoded as follows. */
const Prob pretend_its_huffman [num_ymodes - 1] =
{ 128, 128, 128, 128};
Ymode = (intra_mbmode) treed_read(d, ymode_tree,
pretend_its_huffman);
---- End code block ----------------------------------------
Since it greatly facilitates re-use of reference code, and since there is no real reason to do otherwise, it is strongly suggested that any decoder implementation use exactly the same enumeration values and probability table layouts as those described in this document (and in the reference code) for all tree-coded data in VP8.
参照コードの再利用を大幅に促進するため、そうしないとする本当の理由はないため、デコーダーの実装は、このドキュメントで説明したものとまったく同じ列挙値と確率テーブルレイアウトを使用することを強くお勧めします（および参照コード）VP8のすべてのツリーコーディングデータの。
The uncompressed data chunk at the start of each frame and at the first part of the first data partition contains information pertaining to the frame as a whole. We list the fields in the order of occurrence. Most of the header decoding occurs in the reference decoder file dixie.c (Section 20.4).
各フレームの開始時と最初のデータパーティションの最初の部分で、圧縮されていないデータチャンクには、フレーム全体に関連する情報が含まれています。発生順にフィールドをリストします。ヘッダーデコードのほとんどは、参照デコーダーファイルdixie.c（セクション20.4）で発生します。
The uncompressed data chunk comprises a common (for key frames and interframes) 3-byte frame tag that contains four fields, as follows:
非圧縮データチャンクは、次のように、4つのフィールドを含む共通（キーフレームとインターフレームの場合）3バイトフレームタグで構成されています。
1. A 1-bit frame type (0 for key frames, 1 for interframes).
1. 1ビットフレームタイプ（キーフレームの場合は0、インターフレームの場合は1）。
2. A 3-bit version number (0 - 3 are defined as four different profiles with different decoding complexity; other values may be defined for future variants of the VP8 data format).
2. 3ビットバージョン番号（0-3は、異なるデコードの複雑さを持つ4つの異なるプロファイルとして定義されます。VP8データ形式の将来のバリアントに対して他の値が定義される場合があります）。
3. A 1-bit show_frame flag (0 when current frame is not for display, 1 when current frame is for display).
3. 1ビットshow_frameフラグ（0のフレームが表示されない場合は0、現在のフレームが表示される場合は1）。
4. A 19-bit field containing the size of the first data partition in bytes.
4. バイト内の最初のデータパーティションのサイズを含む19ビットフィールド。
The version number setting enables or disables certain features in the bitstream, as follows:
次のように、バージョン番号設定では、ビットストリーム内の特定の機能を有効または無効にします。
+---------+-------------------------+-------------+
| Version | Reconstruction Filter | Loop Filter |
+---------+-------------------------+-------------+
| 0 | Bicubic | Normal |
| | | |
| 1 | Bilinear | Simple |
| | | |
| 2 | Bilinear | None |
| | | |
| 3 | None | None |
| | | |
| Other | Reserved for future use | |
+---------+-------------------------+-------------+
The reference software also adjusts the loop filter based on version number, as per the table above. Version number 1 implies a "simple" loop filter, and version numbers 2 and 3 imply no loop filter. However, the "simple" filter setting in this context has no effect whatsoever on the decoding process, and the "no loop filter" setting only forces the reference encoder to set filter level equal to 0. Neither affect the decoding process. In decoding, the only loop filter settings that matter are those in the frame header.
参照ソフトウェアは、上記の表に従って、バージョン番号に基づいてループフィルターも調整します。バージョン番号1は、「シンプルな」ループフィルターを意味し、バージョン番号2と3はループフィルターがないことを意味します。ただし、このコンテキストでの「シンプルな」フィルター設定は、デコードプロセスにまったく効果がなく、「No Loop Filter」設定は、参照エンコーダーのみを0に等しく設定します。どちらもデコードプロセスに影響しません。デコードでは、重要なループフィルター設定のみがフレームヘッダーの設定です。
For key frames, the frame tag is followed by a further 7 bytes of uncompressed data, as follows:
キーフレームの場合、フレームタグの後に、次のように、さらに7バイトの非圧縮データが続きます。
---- Begin code block --------------------------------------
Start code byte 0 0x9d Start code byte 1 0x01 Start code byte 2 0x2a
開始コードバイト0 0x9d開始コードバイト1 0x01開始コードバイト2 0x2a
16 bits : (2 bits Horizontal Scale << 14) | Width (14 bits)
16 bits : (2 bits Vertical Scale << 14) | Height (14 bits)
---- End code block ----------------------------------------
The following source code segment illustrates validation of the start code and reading the width, height, and scale factors for a key frame.
次のソースコードセグメントは、開始コードの検証と、キーフレームの幅、高さ、およびスケール係数の読み取りを示しています。
---- Begin code block --------------------------------------
unsigned char *c = pbi->source+3;
// vet via sync code
if (c[0]!=0x9d||c[1]!=0x01||c[2]!=0x2a)
return -1;
---- End code block ----------------------------------------
Where pbi->source points to the beginning of the frame.
ここで、pbi->ソースはフレームの始まりを指します。
The following code reads the image dimension from the bitstream:
次のコードは、ビットストリームの画像次元を読み取ります。
---- Begin code block --------------------------------------
pc->Width = swap2(*(unsigned short*)(c+3))&0x3fff;
pc->horiz_scale = swap2(*(unsigned short*)(c+3))>>14;
pc->Height = swap2(*(unsigned short*)(c+5))&0x3fff;
pc->vert_scale = swap2(*(unsigned short*)(c+5))>>14;
---- End code block ----------------------------------------
Where the swap2 macro takes care of the endian on a different platform:
SWAP2 Macroが別のプラットフォームでEndianの世話をする場合：
---- Begin code block --------------------------------------
#if defined(__ppc__) || defined(__ppc64__)
# define swap2(d) \
((d&0x000000ff)<<8) | \
((d&0x0000ff00)>>8)
#else
# define swap2(d) d
#endif
---- End code block ----------------------------------------
While each frame is encoded as a raster scan of 16x16 macroblocks, the frame dimensions are not necessarily evenly divisible by 16. In this case, write ew = 16 - (width & 15) and eh = 16 - (height & 15) for the excess width and height, respectively. Although they are
各フレームは16x16マクロブロックのラスタースキャンとしてエンコードされていますが、フレームの寸法は必ずしも16で均等に分割できません。それぞれ過剰な幅と高さ。彼らはそうですが
encoded, the last ew columns and eh rows are not actually part of the image and should be discarded before final output. However, these "excess pixels" should be maintained in the internal reconstruction buffer used to predict ensuing frames.
エンコードされた最後のEW列とEH行は、実際には画像の一部ではなく、最終出力の前に破棄する必要があります。ただし、これらの「過剰ピクセル」は、次のフレームを予測するために使用される内部再構成バッファーで維持する必要があります。
The scaling specifications for each dimension are encoded as follows.
各ディメンションのスケーリング仕様は、次のようにエンコードされます。
+-------+--------------------------------------+
| Value | Scaling |
+-------+--------------------------------------+
| 0 | No upscaling (the most common case). |
| | |
| 1 | Upscale by 5/4. |
| | |
| 2 | Upscale by 5/3. |
| | |
| 3 | Upscale by 2. |
+-------+--------------------------------------+
Upscaling does not affect the reconstruction buffer, which should be maintained at the encoded resolution. Any reasonable method of upsampling (including any that may be supported by video hardware in the playback environment) may be used. Since scaling has no effect on decoding, we do not discuss it any further.
アップスケーリングは、エンコードされた解像度で維持する必要がある再構築バッファーに影響しません。アップサンプリングの合理的な方法（再生環境でビデオハードウェアによってサポートされる可能性があるものを含む）が使用される場合があります。スケーリングはデコードに影響を与えないため、これ以上議論しません。
As discussed in Section 5, allocation (or re-allocation) of data structures (such as the reconstruction buffer) whose size depends on dimension will be triggered here.
セクション5で説明したように、サイズが次元に依存するデータ構造（または再構成バッファなど）の割り当て（または再配分）がここでトリガーされます。
+-------+------------------------------------------+
| Field | Value |
+-------+------------------------------------------+
| L(1) | 1-bit color space type specification |
| | |
| L(1) | 1-bit pixel value clamping specification |
+-------+------------------------------------------+
The color space type bit is encoded as follows:
カラースペースタイプビットは次のようにエンコードされます。
o 0 - YUV color space similar to the YCrCb color space defined in [ITU-R_BT.601]
o 0 -[itu -r_bt.601]で定義されているycrcbカラースペースに似たyuvカラースペース
o 1 - Reserved for future use
o 1-将来の使用のために予約されています
The pixel value clamping type bit is encoded as follows:
ピクセル値クランプタイプビットは、次のようにエンコードされます。
o 0 - Decoders are required to clamp the reconstructed pixel values to between 0 and 255 (inclusive).
o 0-再構築されたピクセル値を0〜255（包括的）にクランプするには、デコーダーが必要です。
o 1 - Reconstructed pixel values are guaranteed to be between 0 and 255; no clamping is necessary.
o 1-再構築されたピクセル値は、0〜255の間で保証されています。クランプは必要ありません。
Information in this subsection does not appear in interframes.
このサブセクションの情報は、インターフレームには表示されません。
This subsection contains probability and value information for implementing segment adaptive adjustments to default decoder behavior. The data in this subsection is used in the decoding of the ensuing per-segment information and applies to the entire frame. When segment adaptive adjustments are enabled, each macroblock will be assigned a segment ID. Macroblocks with the same segment ID belong to the same segment and have the same adaptive adjustments over default baseline values for the frame. The adjustments can be quantizer level or loop filter strength.
このサブセクションには、デフォルトのデコーダー動作にセグメント適応調整を実装するための確率と値情報が含まれています。このサブセクションのデータは、その後のセグメントごとの情報のデコードで使用され、フレーム全体に適用されます。セグメント適応調整が有効になると、各マクロブロックにセグメントIDが割り当てられます。同じセグメントIDを持つマクロブロックは、同じセグメントに属し、フレームのデフォルトのベースライン値よりも同じ適応調整を行います。調整は、量子化レベルまたはループフィルター強度です。
The context for decoding this feature at the macroblock level is provided by a subsection in the frame header, which contains:
マクロブロックレベルでこの機能をデコードするためのコンテキストは、以下を含むフレームヘッダーのサブセクションによって提供されます。
1. A segmentation_enabled flag that enables the feature for this frame if set to 1, and disables it if set to 0. The following fields occur if the feature is enabled.
1. このフレームの機能を1に設定すると、0に設定されている場合は無効にするセグメンテーション_エンブルフラグ。機能が有効になっている場合に次のフィールドが発生します。
2. L(1) indicates if the segment map is updated for the current frame (update_mb_segmentation_map).
2. L（1）は、現在のフレーム（update_mb_segmentation_map）に対してセグメントマップが更新されているかどうかを示します。
3. L(1) indicates if the segment feature data items are updated for the current frame (update_segment_feature_data).
3. L（1）は、セグメント機能データ項目が現在のフレーム（update_segment_feature_data）に対して更新されているかどうかを示します。
4. If Item 3 above (update_segment_feature_data) is 1, the following fields occur:
4. 上記の項目3（update_segment_feature_data）が1の場合、次のフィールドが発生します。
a. L(1), the mode of segment feature data (segment_feature_mode), can be absolute-value mode (0) or delta value mode (1).
a. l（1）、セグメント特徴データ（segment_feature_mode）のモードは、絶対値モード（0）またはデルタ値モード（1）です。
b. Segment feature data items are decoded segment by segment for each segment feature. For every data item, a one-bit flag indicates whether the item is 0, or a non-zero value to be decoded. If the value is non-zero, then the value is decoded as a magnitude L(n), followed by a one-bit sign (L(1) -- 0 for positive and 1 for negative). The length n can be looked up from a pre-defined length table for all feature data.
b. セグメント機能データ項目は、各セグメント機能のセグメントごとにデコードされたセグメントです。すべてのデータ項目について、1ビットフラグは、アイテムが0であるか、非ゼロ値がデコードされるかを示します。値がゼロ以外の場合、値はマグニチュードL（n）としてデコードされ、その後に1ビットの符号が続きます（陽性の場合はl（1）、ネガの場合は1）。長さnは、すべての機能データの事前定義された長さテーブルから調べることができます。
5. If the L(1) flag as noted in Item 2 above is set to 1, the probabilities of the decoding tree for the segment map are decoded from the bitstream. Each probability is decoded with a one-bit flag indicating whether the probability is the default value of 255 (flag is set to 0), or an 8-bit value, L(8), from the bitstream.
5. 上記の項目2に記載されているL（1）フラグが1に設定されている場合、セグメントマップのデコードツリーの確率はビットストリームからデコードされます。各確率は、ビットストリームからの確率がデフォルト値（フラグが0に設定されている）、または8ビット値L（8）であるかどうかを示す1ビットフラグでデコードされます。
The layout and semantics supporting this feature at the macroblock level are described in Section 10.
マクロブロックレベルでこの機能をサポートするレイアウトとセマンティクスは、セクション10で説明されています。
VP8 supports two types of loop filters having different computational complexity. The following bits occur in the header to support the selection of the baseline type, strength, and sharpness behavior of the loop filter used for the current frame.
VP8は、異なる計算の複雑さを持つ2種類のループフィルターをサポートします。次のビットは、現在のフレームに使用されるループフィルターのベースラインタイプ、強度、およびシャープネス動作の選択をサポートするために、ヘッダーで発生します。
+-------+-------------------+
| Index | Description |
+-------+-------------------+
| L(1) | filter_type |
| | |
| L(6) | loop_filter_level |
| | |
| L(3) | sharpness_level |
+-------+-------------------+
The meaning of these numbers will be further explained in Section 15.
これらの数値の意味については、セクション15でさらに説明します。
VP8 has a feature in the bitstream that enables adjustment of the loop filter level based on a macroblock's prediction mode and reference frame. The per-macroblock adjustment is done through delta values against the default loop filter level for the current frame. This subsection contains flag and value information for implementing per-macroblock loop filter level adjustment to default decoder behavior. The data in this section is used in the decoding of the ensuing per-macroblock information and applies to the entire frame.
VP8には、マクロブロックの予測モードと参照フレームに基づいてループフィルターレベルの調整を可能にするビットストリームに機能があります。マクロブロックごとの調整は、現在のフレームのデフォルトループフィルターレベルに対するデルタ値を通じて行われます。このサブセクションには、デフォルトのデコーダー動作にマクロブロックごとのループフィルターレベル調整を実装するためのフラグと値情報が含まれています。このセクションのデータは、その後のマクロブロックごとの情報のデコードで使用され、フレーム全体に適用されます。
L(1) is a one-bit flag indicating if the macroblock loop filter adjustment is on for the current frame. 0 means that such a feature is not supported in the current frame, and 1 means this feature is enabled for the current frame.
L（1）は、現在のフレームに対してマクロブロックループフィルターの調整がオンかどうかを示す1ビットフラグです。0は、このような機能が現在のフレームではサポートされていないことを意味し、1つはこの機能が現在のフレームで有効になっていることを意味します。
Whether the adjustment is based on a reference frame or encoding mode, the adjustment of the loop filter level is done via a delta value against a baseline loop filter value. The delta values are updated for the current frame if an L(1) bit, mode_ref_lf_delta_update, takes the value 1. There are two groups of delta values: One group of delta values is for reference frame-based adjustments, and the other group is for mode-based adjustments. The number of delta values in the two groups is MAX_REF_LF_DELTAS and MAX_MODE_LF_DELTAS, respectively. For every value within the two groups, there is a one-bit L(1) to indicate if the particular value is updated. When one is updated (1), it is transmitted as a six-bit-magnitude L(6) followed by a one-bit sign flag (L(1) -- 0 for positive and 1 for negative).
調整が参照フレームまたはエンコードモードに基づいているかどうかにかかわらず、ループフィルターレベルの調整は、ベースラインループフィルター値に対するデルタ値を介して行われます。l（1）ビット、mode_ref_lf_delta_updateの場合、デルタ値は現在のフレームで更新されます。値1を取得します。モードベースの調整用。2つのグループのデルタ値の数は、それぞれMAX_REF_LF_DELTASとMAX_MODE_LF_DELTASです。2つのグループ内のすべての値について、特定の値が更新されているかどうかを示す1ビットL（1）があります。1つが更新されると（1）、6ビットマグニチュードL（6）として送信され、その後に1ビットサインフラグが続きます（l（1）-0陽性、ネガの場合は1）。
VP8 allows DCT coefficients to be packed into multiple partitions, besides the first partition with header and per-macroblock prediction information, so the decoder can perform parallel decoding in an efficient manner. A two-bit L(2) is used to indicate the number of coefficient data partitions within a compressed frame. The two bits are defined in the following table:
VP8を使用すると、DCT係数を複数のパーティションに詰め込むことができ、ヘッダーとマクロブロックごとの予測情報を備えた最初のパーティションに加えて、デコーダーは効率的な方法で並列デコードを実行できます。2ビットL（2）を使用して、圧縮フレーム内の係数データパーティションの数を示します。2つのビットは、次の表に定義されています。
+-------+-------+----------------------+
| Bit 1 | Bit 0 | Number of Partitions |
+-------+-------+----------------------+
| 0 | 0 | 1 |
| | | |
| 0 | 1 | 2 |
| | | |
| 1 | 0 | 4 |
| | | |
| 1 | 1 | 8 |
+-------+-------+----------------------+
Offsets are embedded in the bitstream to provide the decoder direct access to token partitions. If the number of data partitions is greater than 1, the size of each partition (except the last) is written in 3 bytes (24 bits). The size of the last partition is the remainder of the data not used by any of the previous partitions.
オフセットは、トークンパーティションへのデコーダー直接アクセスを提供するためにビットストリームに埋め込まれています。データパーティションの数が1を超える場合、各パーティションのサイズ（最後を除く）は3バイト（24ビット）で記述されます。最後のパーティションのサイズは、以前のパーティションのいずれでも使用されないデータの残りです。
The partitioned data are consecutive in the bitstream, so the size can also be used to calculate the offset of each partition. The following pseudocode illustrates how the size/offset is defined by the three bytes in the bitstream.
パーティション化されたデータはビットストリームで連続しているため、サイズを使用して各パーティションのオフセットを計算することもできます。次の擬似コードは、ビットストリームの3バイトによってサイズ/オフセットがどのように定義されるかを示しています。
---- Begin code block --------------------------------------
Offset/size = (uint32)(byte0) + ((uint32)(byte1)<<8)
+ ((uint32)(byte2)<<16);
---- End code block ----------------------------------------
All residue signals are specified via a quantized 4x4 DCT applied to the Y, U, V, or Y2 subblocks of a macroblock. As detailed in Section 14, before inverting the transform, each decoded coefficient is multiplied by one of six dequantization factors, the choice of which depends on the plane (Y, chroma = U or V, Y2) and coefficient position (DC = coefficient 0, AC = coefficients 1-15). The six values are specified using 7-bit indices into six corresponding fixed tables (the tables are given in Section 14).
すべての残基シグナルは、マクロブロックのY、U、V、またはY2サブブロックに適用される量子化された4x4 DCTを介して指定されます。セクション14で詳述されているように、変換を反転させる前に、デコードされた各係数に6つの非定量化係数のいずれかを掛けます。、AC =係数1-15）。6つの値は、7ビットインデックスを使用して6つの対応する固定テーブルに指定されています（テーブルはセクション14に記載されています）。
The first 7-bit index gives the dequantization table index for Y-plane AC coefficients, called yac_qi. It is always coded and acts as a baseline for the other 5 quantization indices, each of which is represented by a delta from this baseline index. Pseudocode for reading the indices follows:
最初の7ビットインデックスは、YAC_QIと呼ばれるYプレーンAC係数の不安定化テーブルインデックスを提供します。これは常にコーディングされており、他の5つの量子化インデックスのベースラインとして機能し、それぞれがこのベースラインインデックスのデルタで表されます。インデックスを読むための擬似コードは次のとおりです。
---- Begin code block --------------------------------------
yac_qi = L(7); /* Y ac index always specified */
ydc_delta = F? delta(): 0; /* Y dc delta specified if
flag is true */
y2dc_delta = F? delta(): 0; /* Y2 dc delta specified if
flag is true */
y2ac_delta = F? delta(): 0; /* Y2 ac delta specified if
flag is true */
uvdc_delta = F? delta(): 0; /* chroma dc delta specified
if flag is true */
uvac_delta = F? delta(): 0; /* chroma ac delta specified
if flag is true */
---- End code block ----------------------------------------
Where delta() is the process to read 5 bits from the bitstream to determine a signed delta value:
ここで、delta（）は、署名されたデルタ値を決定するためにビットストリームから5ビットを読み取るプロセスです。
+-------+--------------------------------------------------+
| Index | Description |
+-------+--------------------------------------------------+
| L(4) | Magnitude of delta |
| | |
| L(1) | Sign of delta, 0 for positive and 1 for negative |
+-------+--------------------------------------------------+
For key frames, both the golden frame and the altref frame are refreshed/ replaced by the current reconstructed frame, by default. For non-key frames, VP8 uses two bits to indicate whether the two frame buffers are refreshed, using the reconstructed current frame:
キーフレームの場合、ゴールデンフレームとアルトレフフレームの両方が、デフォルトで現在の再構築されたフレームに更新/置き換えられます。非キーフレームの場合、VP8は2つのビットを使用して、再構築された電流フレームを使用して、2つのフレームバッファーが更新されているかどうかを示します。
+-------+----------------------------------------------------------+
| Index | Description |
+-------+----------------------------------------------------------+
| L(1) | Whether golden frame is refreshed (0 for no, 1 for yes). |
| | |
| L(1) | Whether altref frame is refreshed (0 for no, 1 for yes). |
+-------+----------------------------------------------------------+
When the flag for the golden frame is 0, VP8 uses 2 more bits in the bitstream to indicate whether the buffer (and which buffer) is copied to the golden frame, or if no buffer is copied:
ゴールデンフレームのフラグが0の場合、VP8はビットストリームでさらに2ビットを使用して、バッファー（およびバッファー）がゴールデンフレームにコピーされるか、バッファーがコピーされないかどうかを示します。
+-------+------------------------------------------+
| Index | Description |
+-------+------------------------------------------+
| L(2) | Buffer copy flag for golden frame buffer |
+-------+------------------------------------------+
Where:
ただし：
o 0 means no buffer is copied to the golden frame
o 0は、バッファーがゴールデンフレームにコピーされないことを意味します
o 1 means last_frame is copied to the golden frame
o 1は、last_frameがゴールデンフレームにコピーされることを意味します
o 2 means alt_ref_frame is copied to the golden frame
o 2は、alt_ref_frameがゴールデンフレームにコピーされることを意味します
Similarly, when the flag for altref is 0, VP8 uses 2 bits in the bitstream to indicate which buffer is copied to alt_ref_frame.
同様に、Altrefのフラグが0の場合、VP8はビットストリームで2ビットを使用して、どのバッファーがalt_ref_frameにコピーされているかを示します。
+-------+------------------------------------------+
| Index | Description |
+-------+------------------------------------------+
| L(2) | Buffer copy flag for altref frame buffer |
+-------+------------------------------------------+
Where:
ただし：
o 0 means no buffer is copied to the altref frame
o 0は、バッファーがaltRefフレームにコピーされないことを意味します
o 1 means last_frame is copied to the altref frame
o 1は、last_frameがaltRefフレームにコピーされることを意味します
o 2 means golden_frame is copied to the altref frame
o 2は、Golden_FrameがAltRefフレームにコピーされることを意味します
Two bits are transmitted for ref_frame_sign_bias for golden_frame and alt_ref_frame, respectively.
Golden_FrameとAlt_Ref_FrameのREF_FRAME_SIGN_BIAS用に2つのビットが送信されます。
+-------+---------------------------------+
| Index | Description |
+-------+---------------------------------+
| L(1) | Sign bias flag for golden frame |
| | |
| L(1) | Sign bias flag for altref frame |
+-------+---------------------------------+
These values are used to control the sign of the motion vectors when a golden frame or an altref frame is used as the reference frame for a macroblock.
これらの値は、ゴールデンフレームまたはアルトレフフレームがマクロブロックの参照フレームとして使用される場合のモーションベクトルの記号を制御するために使用されます。
VP8 uses one bit, L(1), to indicate if the last frame reference buffer is refreshed using the constructed current frame. On a key frame, this bit is overridden, and the last frame buffer is always refreshed.
VP8は、構築された電流フレームを使用して最後のフレーム参照バッファーが更新されているかどうかを示すために、1ビットL（1）を使用します。キーフレームでは、このビットはオーバーライドされ、最後のフレームバッファーは常に更新されます。
This field contains updates to the probability tables used to decode DCT coefficients. For each of the probabilities in the tables, there is an L(1) flag indicating if the probability is updated for the current frame, and if the L(1) flag is set to 1, there follows an additional 8-bit value representing the new probability value. These tables are maintained across interframes but are of course replaced with their defaults at the beginning of every key frame.
このフィールドには、DCT係数をデコードするために使用される確率テーブルの更新が含まれています。テーブル内の各確率について、現在のフレームの確率が更新されているかどうかを示すL（1）フラグがあり、L（1）フラグが1に設定されている場合、追加の8ビット値を表す追加の8ビット値が続きます。新しい確率値。これらのテーブルはインターフレーム全体に維持されていますが、もちろん、すべてのキーフレームの先頭にデフォルトに置き換えられます。
The layout and semantics of this field will be taken up in Section 13.
このフィールドのレイアウトとセマンティクスは、セクション13で取り上げられます。
+-------+-----------------------------------------------------------+
| Index | Description |
+-------+-----------------------------------------------------------+
| L(1) | mb_no_skip_coeff. This flag indicates at the frame level |
| | if skipping of macroblocks with no non-zero coefficients |
| | is enabled. If it is set to 0, then prob_skip_false is |
| | not read and mb_skip_coeff is forced to 0 for all |
| | macroblocks (see Sections 11.1 and 12.1). |
| | |
| L(8) | prob_skip_false = probability used for decoding a |
| | macroblock-level flag, which indicates if a macroblock |
| | has any non-zero coefficients. Only read if |
| | mb_no_skip_coeff is 1. |
| | |
| L(8) | prob_intra = probability that a macroblock is "intra" |
| | predicted (that is, predicted from the already-encoded |
| | portions of the current frame), as opposed to "inter" |
| | predicted (that is, predicted from the contents of a |
| | prior frame). |
| | |
| L(8) | prob_last = probability that an inter-predicted |
| | macroblock is predicted from the immediately previous |
| | frame, as opposed to the most recent golden frame or |
| | altref frame. |
| | |
| L(8) | prob_gf = probability that an inter-predicted macroblock |
| | is predicted from the most recent golden frame, as |
| | opposed to the altref frame. |
| | |
| F | If true, followed by four L(8)s updating the |
| | probabilities for the different types of intra-prediction |
| | for the Y plane. These probabilities correspond to the |
| | four interior nodes of the decoding tree for intra-Y |
| | modes in an interframe, that is, the even positions in |
| | the ymode_tree array given above. |
| | |
| F | If true, followed by three L(8)s updating the |
| | probabilities for the different types of intra-prediction |
| | for the chroma planes. These probabilities correspond to |
| | the even positions in the uv_mode_tree array given above. |
| | |
| X | Motion vector probability update. Details are given in |
| | Section 17.2, "Probability Updates". |
+-------+-----------------------------------------------------------+
Decoding of this portion of the frame header is handled in the reference decoder file dixie.c (Section 20.4).
フレームヘッダーのこの部分のデコードは、参照デコーダーファイルdixie.c（セクション20.4）で処理されます。
+-------+-----------------------------------------------------------+
| Index | Description |
+-------+-----------------------------------------------------------+
| L(1) | mb_no_skip_coeff. This flag indicates at the frame level |
| | if skipping of macroblocks with no non-zero coefficients |
| | is enabled. If it is set to 0, then prob_skip_false is |
| | not read and mb_skip_coeff is forced to 0 for all |
| | macroblocks (see Sections 11.1 and 12.1). |
| | |
| L(8) | prob_skip_false = Probability used for decoding a |
| | macroblock-level flag, which indicates if a macroblock |
| | has any non-zero coefficients. Only read if |
| | mb_no_skip_coeff is 1. |
+-------+-----------------------------------------------------------+
Decoding of this portion of the frame header is handled in the reference decoder file modemv.c (Section 20.11).
フレームヘッダーのこの部分のデコードは、参照デコーダーファイルmodemv.c（セクション20.11）で処理されます。
This completes the layout of the frame header. The remainder of the first data partition consists of macroblock-level prediction data.
これにより、フレームヘッダーのレイアウトが完了します。最初のデータパーティションの残りは、マクロブロックレベルの予測データで構成されています。
After the frame header is processed, all probabilities needed to decode the prediction and residue data are known and will not change until the next frame.
フレームヘッダーが処理された後、予測のデコードに必要なすべての確率と残基データが既知であり、次のフレームまで変更されません。
Every macroblock may optionally override some of the default behaviors of the decoder. Specifically, VP8 uses segment-based adjustments to support changing quantizer level and loop filter level for a macroblock. When the segment-based adjustment feature is enabled for a frame, each macroblock within the frame is coded with a segment_id. This effectively segments all the macroblocks in the current frame into a number of different segments. Macroblocks within the same segment behave exactly the same for quantizer and loop filter level adjustments.
すべてのマクロブロックは、オプションでデコーダーのデフォルト動作の一部をオーバーライドする場合があります。具体的には、VP8はセグメントベースの調整を使用して、マクロブロックの変化する量子化レベルとループフィルターレベルをサポートします。フレームに対してセグメントベースの調整機能が有効になっている場合、フレーム内の各マクロブロックはsegment_idでコーディングされます。これにより、現在のフレーム内のすべてのマクロブロックが多くの異なるセグメントに効果的にセグリングされます。同じセグメント内のマクロブロックは、量子化器とループフィルターレベルの調整に対してまったく同じように動作します。
If both the segmentation_enabled and update_mb_segmentation_map flags in subsection B of the frame header take a value of 1, the prediction data for each (intra- or inter-coded) macroblock begins with a specification of segment_id for the current macroblock. It is decoded using this simple tree ...
FrameヘッダーのサブセクションBのSegmentation_Enabledとupdate_mb_segmentation_mapフラグの両方が1の値を取得する場合、各マクロブロックの各マクロブロックの予測データは、現在のマクロブロックのSEGAME_IDの仕様から始まります。この単純な木を使用してデコードされています...
---- Begin code block --------------------------------------
const tree_index mb_segment_tree [2 * (4-1)] =
{
2, 4, /* root: "0", "1" subtrees */
-0, -1, /* "00" = 0th value, "01" = 1st value */
-2, -3 /* "10" = 2nd value, "11" = 3rd value */
}
---- End code block ----------------------------------------
... combined with a 3-entry probability table, mb_segment_tree_probs[3]. The macroblock's segment_id is used later in the decoding process to look into the segment_feature_data table and determine how the quantizer and loop filter levels are adjusted.
... 3エントリ確率表、MB_Segment_tree_Probs [3]と組み合わせる。Macroblockのsegment_idは、デコードプロセスの後半で使用され、segment_feature_dataテーブルを調べ、量子化器とループフィルターのレベルの調整方法を決定します。
The decoding of segment_id, together with the parsing of intra-prediction modes (which is taken up next), is implemented in the reference decoder file modemv.c.
SEGAGE_IDのデコードは、予測内モード（次に取り上げられる）の解析とともに、参照デコーダーファイルmodemv.cに実装されています。
After specifying the features described above, the macroblock prediction record next specifies the prediction mode used for the macroblock.
上記の機能を指定した後、マクロブロック予測レコードは次に、マクロブロックに使用される予測モードを指定します。
The single bool flag is decoded using prob_skip_false if and only if mb_no_skip_coeff is set to 1 (see Sections 9.10 and 9.11). If mb_no_skip_coeff is set to 0, then this value defaults to 0.
単一のブールフラグは、mb_no_skip_coeffが1に設定されている場合にのみ、prob_skip_falseを使用してデコードされます（セクション9.10および9.11を参照）。MB_NO_SKIP_COEFFが0に設定されている場合、この値はデフォルト0になります。
First comes the luma specification of type intra_mbmode, coded using the kf_ymode_tree, as described in Section 8 and repeated here for convenience:
最初に、セクション8で説明されているように、kf_ymode_treeを使用してコード化された型intra_mbmodeのluma仕様が登場し、ここで繰り返されます。
---- Begin code block --------------------------------------
typedef enum
{
DC_PRED, /* predict DC using row above and column to the left */
V_PRED, /* predict rows using row above */
H_PRED, /* predict columns using column to the left */
TM_PRED, /* propagate second differences a la "True Motion" */
B_PRED, /* each Y subblock is independently predicted */
num_uv_modes = B_PRED, /* first four modes apply to chroma */
num_ymodes /* all modes apply to luma */
}
intra_mbmode;
const tree_index kf_ymode_tree [2 * (num_ymodes - 1)] =
{
-B_PRED, 2, /* root: B_PRED = "0", "1" subtree */
4, 6, /* "1" subtree has 2 descendant subtrees */
-DC_PRED, -V_PRED, /* "10" subtree: DC_PRED = "100",
V_PRED = "101" */
-H_PRED, -TM_PRED /* "11" subtree: H_PRED = "110",
TM_PRED = "111" */
};
---- End code block ----------------------------------------
For key frames, the Y mode is decoded using a fixed probability array as follows:
キーフレームの場合、yモードは、次のように固定確率配列を使用してデコードされます。
---- Begin code block --------------------------------------
const Prob kf_ymode_prob [num_ymodes - 1] = { 145, 156, 163, 128};
Ymode = (intra_mbmode) treed_read(d, kf_ymode_tree, kf_ymode_prob);
---- End code block ----------------------------------------
d is of course the bool_decoder being used to read the first data partition.
Dはもちろん、最初のデータパーティションを読み取るために使用されているbool_decoderです。
If the Ymode is B_PRED, it is followed by a (tree-coded) mode for each of the 16 Y subblocks. The 10 subblock modes and their coding tree are as follows:
YModeのB_PREDの場合、16Yサブブロックのそれぞれに対して（ツリーコーディング）モードが続きます。10のサブブロックモードとそのコーディングツリーは次のとおりです。
---- Begin code block --------------------------------------
typedef enum
{
B_DC_PRED, /* predict DC using row above and column
to the left */
B_TM_PRED, /* propagate second differences a la
"True Motion" */
B_VE_PRED, /* predict rows using row above */
B_HE_PRED, /* predict columns using column to the left */
B_LD_PRED, /* southwest (left and down) 45 degree diagonal
prediction */
B_RD_PRED, /* southeast (right and down) "" */
B_VR_PRED, /* SSE (vertical right) diagonal prediction */
B_VL_PRED, /* SSW (vertical left) "" */
B_HD_PRED, /* ESE (horizontal down) "" */
B_HU_PRED, /* ENE (horizontal up) "" */
num_intra_bmodes } intra_bmode;
num_intra_bmodes} intra_bmode;
/* Coding tree for the above, with implied codings as comments */
const tree_index bmode_tree [2 * (num_intra_bmodes - 1)] =
{
-B_DC_PRED, 2, /* B_DC_PRED = "0" */
-B_TM_PRED, 4, /* B_TM_PRED = "10" */
-B_VE_PRED, 6, /* B_VE_PRED = "110" */
8, 12,
-B_HE_PRED, 10, /* B_HE_PRED = "11100" */
-B_RD_PRED, -B_VR_PRED, /* B_RD_PRED = "111010",
B_VR_PRED = "111011" */
-B_LD_PRED, 14, /* B_LD_PRED = "111110" */
-B_VL_PRED, 16, /* B_VL_PRED = "1111110" */
-B_HD_PRED, -B_HU_PRED /* HD = "11111110",
HU = "11111111" */
};
---- End code block ----------------------------------------
The first four modes are smaller versions of the similarly named 16x16 modes above, albeit with slightly different numbering. The last six "diagonal" modes are unique to luma subblocks.
最初の4つのモードは、わずかに異なる番号が付いているにもかかわらず、上記の16x16モードと同様に名前が付けられた小さなバージョンです。最後の6つの「対角線」モードは、Lumaサブブロックに固有のものです。
The coding of subblock modes in key frames uses the modes already coded for the subblocks to the left of and above the subblock to select a probability array for decoding the current subblock mode. This is our first instance of contextual prediction, and there are several caveats associated with it:
キーフレームでのサブブロックモードのコーディングは、サブブロックの左以降のサブブロックに対して既にコーディングされているモードを使用して、現在のサブブロックモードをデコードするための確率配列を選択します。これは、コンテキスト予測の最初のインスタンスであり、それに関連するいくつかの注意事項があります。
1. The adjacency relationships between subblocks are based on the normal default raster placement of the subblocks.
1. サブブロック間の隣接関係は、サブブロックの通常のデフォルトラスター配置に基づいています。
2. The adjacent subblocks need not lie in the current macroblock. The subblocks to the left of the left-edge subblocks 0, 4, 8, and 12 are the right-edge subblocks 3, 7, 11, and 15, respectively, of the (already coded) macroblock immediately to the left. Similarly, the subblocks above the top-edge subblocks 0, 1, 2, and 3 are the bottom-edge subblocks 12, 13, 14, and 15 of the already-coded macroblock immediately above us.
2. 隣接するサブブロックは、現在のマクロブロックにある必要はありません。左端のサブブロック0、4、8、および12の左側のサブブロックは、それぞれ右端のサブブロック3、7、11、および15です。同様に、トップエッジサブブロック0、1、2、および3の上のサブブロックは、私たちのすぐ上の既にコードされたマクロブロックのボトムエッジサブブロック12、13、14、および15です。
3. For macroblocks on the top row or left edge of the image, some of the predictors will be non-existent. Such predictors are taken to have had the value B_DC_PRED, which, perhaps conveniently, takes the value 0 in the enumeration above. A simple management scheme for these contexts might maintain a row of above predictors and four left predictors. Before decoding the frame, the entire row is initialized to B_DC_PRED; before decoding each row of macroblocks, the four left predictors are also set to B_DC_PRED. After decoding a macroblock, the bottom four subblock modes are copied into the row predictor (at the current position, which then advances to be above the next macroblock), and the right four subblock modes are copied into the left predictor.
3. 画像の一番上の行または左端のマクロブロックの場合、予測因子の一部は存在しません。このような予測因子は、値B_DC_PREDを持っていたと見なされます。これは、おそらく上記の列挙で値0を取得します。これらのコンテキストの単純な管理スキームは、上記の予測因子と4つの左予測因子の行を維持する場合があります。フレームをデコードする前に、行全体がB_DC_PREDに初期化されます。マクロブロックの各行をデコードする前に、4つの左予測子もB_DC_PREDに設定されます。マクロブロックをデコードした後、下の4つのサブブロックモードが行予測子にコピーされ（現在の位置で、次のマクロブロックの上に進む）、右の4つのサブブロックモードが左予測子にコピーされます。
4. Many macroblocks will of course be coded using a 16x16 luma prediction mode. For the purpose of predicting ensuing subblock modes (only), such macroblocks derive a subblock mode, constant throughout the macroblock, from the 16x16 luma mode as follows: DC_PRED uses B_DC_PRED, V_PRED uses B_VE_PRED, H_PRED uses B_HE_PRED, and TM_PRED uses B_TM_PRED.
4. もちろん、多くのマクロブロックは、16x16 LUMA予測モードを使用してコーディングされます。次のサブブロックモード（のみ）を予測するために、このようなマクロブロックは、次のように16x16 LUMAモードからマクロブロック全体で一定のサブブロックモードを導き出します。DC_PREDはB_DC_PREDを使用します。
5. Although we discuss interframe modes in Section 16, we remark here that, while interframes do use all the intra-coding modes described here and below, the subblock modes in an interframe are coded using a single constant probability array that does not depend on any context.
5. セクション16のインターフレームモードについては説明しますが、ここでは、インターフレームはここで説明するすべてのコードモードを使用しますが、インターフレームのサブブロックモードは、コンテキストに依存しない単一の定数確率配列を使用してコーディングされていることに注意してください。。
The dependence of subblock mode probability on the nearby subblock mode context is most easily handled using a three-dimensional constant array:
近くのサブブロックモードコンテキストに対するサブブロックモードの確率の依存性は、3次元定数配列を使用して最も簡単に処理されます。
---- Begin code block --------------------------------------
const Prob kf_bmode_prob [num_intra_bmodes] [num_intra_bmodes] [num_intra_bmodes-1];
const prob kf_bmode_prob [num_intra_bmodes] [num_intra_bmodes] [num_intra_bmodes-1];
---- End code block ----------------------------------------
The outer two dimensions of this array are indexed by the already-coded subblock modes above and to the left of the current block, respectively. The inner dimension is a typical tree probability list whose indices correspond to the even indices of the bmode_tree above. The mode for the j^(th) luma subblock is then
この配列の外側の2つの寸法は、現在のブロックの上と左側の既にコードされたサブブロックモードによってインデックス付けされます。内側の寸法は、上記のbmode_treeの均等なインデックスにインデックスが対応する典型的なツリー確率リストです。j^（th）lumaサブブロックのモードは
---- Begin code block --------------------------------------
Bmode = (intra_bmode) treed_read(d, bmode_tree, kf_bmode_prob
[A] [L]);
---- End code block ----------------------------------------
Where the 4x4 Y subblock index j varies from 0 to 15 in raster order, and A and L are the modes used above and to the left of the j^(th) subblock.
4x4 YサブブロックインデックスJはラスター順序で0から15まで変化し、AとLはj^（th）サブブロックの上と左側に使用されるモードです。
The contents of the kf_bmode_prob array are given at the end of this section.
kf_bmode_prob配列の内容は、このセクションの最後に示されています。
After the Y mode (and optional subblock mode) specification comes the chroma mode. The chroma modes are a subset of the Y modes and are coded using the uv_mode_tree, as described in Section 8 and repeated here for convenience:
Yモード（およびオプションのサブブロックモード）の仕様がクロマモードになります。クロマモードはYモードのサブセットであり、セクション8で説明されているように、UV_Mode_treeを使用してコード化され、ここでは便利なために繰り返されます。
---- Begin code block --------------------------------------
const tree_index uv_mode_tree [2 * (num_uv_modes - 1)] =
{
-DC_PRED, 2, /* root: DC_PRED = "0", "1" subtree */
-V_PRED, 4, /* "1" subtree: V_PRED = "10",
"11" subtree */
-H_PRED, -TM_PRED /* "11" subtree: H_PRED = "110",
TM_PRED = "111" */
};
---- End code block ----------------------------------------
As for the Y modes (in a key frame), the chroma modes are coded using a fixed, contextless probability table:
Yモード（キーフレーム内）に関しては、クロマモードは、固定されたコンテキストレス確率表を使用してコーディングされます。
---- Begin code block --------------------------------------
const Prob kf_uv_mode_prob [num_uv_modes - 1] = { 142, 114, 183};
uv_mode = (intra_mbmode) treed_read(d, uv_mode_tree,
kf_uv_mode_prob);
---- End code block ----------------------------------------
This completes the description of macroblock prediction coding for key frames. As will be discussed in Section 16, the coding of intra modes within interframes is similar, but not identical, to that described here (and in the reference code) for prediction modes and, indeed, for all tree-coded data in VP8.
これにより、キーフレームのマクロブロック予測コーディングの説明が完成します。セクション16で説明するように、インターフレーム内のイントラモードのコーディングは、予測モードについて、そして実際にはVP8のすべてのツリーコーディングデータについて、ここ（および参照コード）と類似していますが、同一ではありません。
Finally, here is the fixed probability table used to decode subblock modes in key frames.
最後に、キーフレームのサブブロックモードをデコードするために使用される固定確率テーブルを次に示します。
---- Begin code block --------------------------------------
const Prob kf_bmode_prob [num_intra_bmodes] [num_intra_bmodes]
[num_intra_bmodes-1] =
{
{
{ 231, 120, 48, 89, 115, 113, 120, 152, 112},
{ 152, 179, 64, 126, 170, 118, 46, 70, 95},
{ 175, 69, 143, 80, 85, 82, 72, 155, 103},
{ 56, 58, 10, 171, 218, 189, 17, 13, 152},
{ 144, 71, 10, 38, 171, 213, 144, 34, 26},
{ 114, 26, 17, 163, 44, 195, 21, 10, 173},
{ 121, 24, 80, 195, 26, 62, 44, 64, 85},
{ 170, 46, 55, 19, 136, 160, 33, 206, 71},
{ 63, 20, 8, 114, 114, 208, 12, 9, 226},
{ 81, 40, 11, 96, 182, 84, 29, 16, 36}
},
{
{ 134, 183, 89, 137, 98, 101, 106, 165, 148},
{ 72, 187, 100, 130, 157, 111, 32, 75, 80},
{ 66, 102, 167, 99, 74, 62, 40, 234, 128},
{ 41, 53, 9, 178, 241, 141, 26, 8, 107},
{ 104, 79, 12, 27, 217, 255, 87, 17, 7},
{ 74, 43, 26, 146, 73, 166, 49, 23, 157},
{ 65, 38, 105, 160, 51, 52, 31, 115, 128},
{ 87, 68, 71, 44, 114, 51, 15, 186, 23},
{ 47, 41, 14, 110, 182, 183, 21, 17, 194},
{ 66, 45, 25, 102, 197, 189, 23, 18, 22}
},
{
{ 88, 88, 147, 150, 42, 46, 45, 196, 205},
{ 43, 97, 183, 117, 85, 38, 35, 179, 61},
{ 39, 53, 200, 87, 26, 21, 43, 232, 171},
{ 56, 34, 51, 104, 114, 102, 29, 93, 77},
{ 107, 54, 32, 26, 51, 1, 81, 43, 31},
{ 39, 28, 85, 171, 58, 165, 90, 98, 64},
{ 34, 22, 116, 206, 23, 34, 43, 166, 73},
{ 68, 25, 106, 22, 64, 171, 36, 225, 114},
{ 34, 19, 21, 102, 132, 188, 16, 76, 124},
{ 62, 18, 78, 95, 85, 57, 50, 48, 51}
},
{
{ 193, 101, 35, 159, 215, 111, 89, 46, 111},
{ 60, 148, 31, 172, 219, 228, 21, 18, 111},
{ 112, 113, 77, 85, 179, 255, 38, 120, 114},
{ 40, 42, 1, 196, 245, 209, 10, 25, 109},
{ 100, 80, 8, 43, 154, 1, 51, 26, 71},
{ 88, 43, 29, 140, 166, 213, 37, 43, 154},
{ 61, 63, 30, 155, 67, 45, 68, 1, 209},
{ 142, 78, 78, 16, 255, 128, 34, 197, 171},
{ 41, 40, 5, 102, 211, 183, 4, 1, 221},
{ 51, 50, 17, 168, 209, 192, 23, 25, 82}
},
{
{ 125, 98, 42, 88, 104, 85, 117, 175, 82},
{ 95, 84, 53, 89, 128, 100, 113, 101, 45},
{ 75, 79, 123, 47, 51, 128, 81, 171, 1},
{ 57, 17, 5, 71, 102, 57, 53, 41, 49},
{ 115, 21, 2, 10, 102, 255, 166, 23, 6},
{ 38, 33, 13, 121, 57, 73, 26, 1, 85},
{ 41, 10, 67, 138, 77, 110, 90, 47, 114},
{ 101, 29, 16, 10, 85, 128, 101, 196, 26},
{ 57, 18, 10, 102, 102, 213, 34, 20, 43},
{ 117, 20, 15, 36, 163, 128, 68, 1, 26}
},
{
{ 138, 31, 36, 171, 27, 166, 38, 44, 229},
{ 67, 87, 58, 169, 82, 115, 26, 59, 179},
{ 63, 59, 90, 180, 59, 166, 93, 73, 154},
{ 40, 40, 21, 116, 143, 209, 34, 39, 175},
{ 57, 46, 22, 24, 128, 1, 54, 17, 37},
{ 47, 15, 16, 183, 34, 223, 49, 45, 183},
{ 46, 17, 33, 183, 6, 98, 15, 32, 183},
{ 65, 32, 73, 115, 28, 128, 23, 128, 205},
{ 40, 3, 9, 115, 51, 192, 18, 6, 223},
{ 87, 37, 9, 115, 59, 77, 64, 21, 47}
},
{
{ 104, 55, 44, 218, 9, 54, 53, 130, 226},
{ 64, 90, 70, 205, 40, 41, 23, 26, 57},
{ 54, 57, 112, 184, 5, 41, 38, 166, 213},
{ 30, 34, 26, 133, 152, 116, 10, 32, 134},
{ 75, 32, 12, 51, 192, 255, 160, 43, 51},
{ 39, 19, 53, 221, 26, 114, 32, 73, 255},
{ 31, 9, 65, 234, 2, 15, 1, 118, 73},
{ 88, 31, 35, 67, 102, 85, 55, 186, 85},
{ 56, 21, 23, 111, 59, 205, 45, 37, 192},
{ 55, 38, 70, 124, 73, 102, 1, 34, 98}
},
{
{ 102, 61, 71, 37, 34, 53, 31, 243, 192},
{ 69, 60, 71, 38, 73, 119, 28, 222, 37},
{ 68, 45, 128, 34, 1, 47, 11, 245, 171},
{ 62, 17, 19, 70, 146, 85, 55, 62, 70},
{ 75, 15, 9, 9, 64, 255, 184, 119, 16},
{ 37, 43, 37, 154, 100, 163, 85, 160, 1},
{ 63, 9, 92, 136, 28, 64, 32, 201, 85},
{ 86, 6, 28, 5, 64, 255, 25, 248, 1},
{ 56, 8, 17, 132, 137, 255, 55, 116, 128},
{ 58, 15, 20, 82, 135, 57, 26, 121, 40}
},
{
{ 164, 50, 31, 137, 154, 133, 25, 35, 218},
{ 51, 103, 44, 131, 131, 123, 31, 6, 158},
{ 86, 40, 64, 135, 148, 224, 45, 183, 128},
{ 22, 26, 17, 131, 240, 154, 14, 1, 209},
{ 83, 12, 13, 54, 192, 255, 68, 47, 28},
{ 45, 16, 21, 91, 64, 222, 7, 1, 197},
{ 56, 21, 39, 155, 60, 138, 23, 102, 213},
{ 85, 26, 85, 85, 128, 128, 32, 146, 171},
{ 18, 11, 7, 63, 144, 171, 4, 4, 246},
{ 35, 27, 10, 146, 174, 171, 12, 26, 128}
},
{
{ 190, 80, 35, 99, 180, 80, 126, 54, 45},
{ 85, 126, 47, 87, 176, 51, 41, 20, 32},
{ 101, 75, 128, 139, 118, 146, 116, 128, 85},
{ 56, 41, 15, 176, 236, 85, 37, 9, 62},
{ 146, 36, 19, 30, 171, 255, 97, 27, 20},
{ 71, 30, 17, 119, 118, 255, 17, 18, 138},
{ 101, 38, 60, 138, 55, 70, 43, 26, 142},
{ 138, 45, 61, 62, 219, 1, 81, 188, 64},
{ 32, 41, 20, 117, 151, 142, 20, 21, 163},
{ 112, 19, 12, 61, 195, 128, 48, 4, 24}
}
};
---- End code block ----------------------------------------
Intraframe prediction uses already-coded macroblocks within the current frame to approximate the contents of the current macroblock. It applies to intra-coded macroblocks in an interframe and to all macroblocks in a key frame.
内部フレーム予測では、現在のマクロブロックの内容を近似するために、現在のフレーム内の既にコードされたマクロブロックを使用します。インターフレーム内のコード中のマクロブロックと、キーフレームのすべてのマクロブロックに適用されます。
Relative to the current macroblock "M", the already-coded macroblocks include all macroblocks above M together with the macroblocks on the same row as, and to the left of, M, though at most four of these macroblocks are actually used: the block "A" directly above M, the blocks immediately to the left and right of A, and the block immediately to the left of M.
現在のマクロブロック「M」と比較して、すでにコーディングされたマクロブロックには、Mを超えるすべてのマクロブロックと、Mのマクロブロックと同じ行と同じマクロブロックが含まれます。「A」の真上の「A」、Aの左右にすぐにブロックが、すぐにMの左側にブロックがブロックされます。
Each of the prediction modes (i.e., means of extrapolation from already-calculated values) uses fairly simple arithmetic on pixel values whose positions, relative to the current position, are defined by the mode.
各予測モード（つまり、すでに計算された値からの外挿）は、現在の位置と比較して位置がモードによって定義されるピクセル値でかなり単純な算術を使用します。
The chroma (U and V) and luma (Y) predictions are independent of each other.
クロマ（uとv）とルーマ（y）の予測は互いに独立しています。
The relative addressing of pixels applied to macroblocks on the upper row or left column of the frame will sometimes cause pixels outside the visible frame to be referenced. Usually such out-of-bounds pixels have an assumed value of 129 for pixels to the left of the leftmost column of the visible frame and 127 for pixels above the top row of the visible frame (including the special case of the pixel above and to the left of the top-left pixel in the visible frame). Exceptions to this (associated to certain modes) will be noted below.
フレームの上の列または左列のマクロブロックに適用されるピクセルの相対的なアドレス指定により、目に見えるフレームの外側のピクセルが参照されることがあります。通常、このような境界外のピクセルは、可視フレームの左端の列の左側のピクセルで129の値、可視フレームの上列の上のピクセルで127の値を持っています（上のピクセルの特殊なケースを含む可視フレームの左上ピクセルの左側）。これの例外（特定のモードに関連付けられています）を以下に示します。
The already-coded macroblocks referenced by intra-prediction have been "reconstructed", that is, have been predicted and residue-adjusted (as described in Section 14), but have not been loop-filtered. While it does process the edges between individual macroblocks and individual subblocks, loop filtering (described in Section 15) is applied to the frame as a whole, after all of the macroblocks have been reconstructed.
予測内で参照されているすでにコードされたマクロブロックは「再構築」されています。つまり、予測され、残留調整が（セクション14で説明されているように）が、ループフィルタリングされていません。個々のマクロブロックと個々のサブブロック間のエッジを処理しますが、すべてのマクロブロックが再構築された後、ループフィルタリング（セクション15で説明）がフレーム全体に適用されます。
The single bool flag is decoded using prob_skip_false if and only if mb_no_skip_coeff is set to 1 (see Sections 9.10 and 9.11). If mb_no_skip_coeff is set to 0, then this value defaults to 0.
単一のブールフラグは、mb_no_skip_coeffが1に設定されている場合にのみ、prob_skip_falseを使用してデコードされます（セクション9.10および9.11を参照）。MB_NO_SKIP_COEFFが0に設定されている場合、この値はデフォルト0になります。
The chroma prediction is a little simpler than the luma prediction, so we treat it first. Each of the chroma modes treats U and V identically; that is, the U and V prediction values are calculated in parallel, using the same relative addressing and arithmetic in each of the two planes.
クロマの予測は、LUMA予測よりも少し簡単ですので、最初に扱います。各クロマモードはuとvを同じように処理します。つまり、UおよびV予測値は、2つの平面のそれぞれで同じ相対アドレス指定と算術を使用して並行して計算されます。
The modes extrapolate prediction values using the 8-pixel row "A" lying immediately above the block (that is, the bottom chroma row of the macroblock immediately above the current macroblock) and the 8-pixel column "L" immediately to the left of the block (that is, the rightmost chroma column of the macroblock immediately to the left of the current macroblock).
モードは、ブロックのすぐ上にある8ピクセルの行「A」（つまり、現在のマクロブロックのすぐ上のマクロブロックの下部クロマ行）と8ピクセルの列「L」をすぐに左側の左側に使用して予測値を推定します。ブロック（つまり、現在のマクロブロックの左側にあるマクロブロックの右端のクロマ列）。
Vertical prediction (chroma mode V_PRED) simply fills each 8-pixel row of the 8x8 chroma block with a copy of the "above" row (A). If the current macroblock lies on the top row of the frame, all 8 of the pixel values in A are assigned the value 127.
垂直予測（Chroma Mode V_Pred）は、8x8 Chromaブロックの各8ピクセルの行を「上」行（a）のコピーに単純に埋めるだけです。現在のマクロブロックがフレームの一番上の行にある場合、Aのピクセル値の8つすべてが値127に割り当てられます。
Similarly, horizontal prediction (H_PRED) fills each 8-pixel column of the 8x8 chroma block with a copy of the "left" column (L). If the current macroblock is in the left column of the frame, all 8 pixel values in L are assigned the value 129.
同様に、水平予測（H_PRED）は、8x8 Chromaブロックの各8ピクセル列に「左」列（L）のコピーを埋めます。現在のマクロブロックがフレームの左列にある場合、Lの8つのピクセル値はすべて値129に割り当てられます。
DC prediction (DC_PRED) fills the 8x8 chroma block with a single value. In the generic case of a macroblock lying below the top row and right of the leftmost column of the frame, this value is the average of the 16 (genuinely visible) pixels in the (union of the) above row A and left column L.
DC予測（DC_PRED）は、8x8クロマブロックに単一の値で埋められます。フレームの左端の列の一番上の行と右下にあるマクロブロックの一般的なケースでは、この値は、上の列Aおよび左列Lの（結合）の（真に見える）ピクセルの平均です。
Otherwise, if the current macroblock lies on the top row of the frame, the average of the 8 pixels in L is used; if it lies in the left column of the frame, the average of the 8 pixels in A is used.
それ以外の場合、現在のマクロブロックがフレームの一番上の行にある場合、Lの8ピクセルの平均が使用されます。フレームの左列にある場合、Aの8ピクセルの平均が使用されます。
Note that the averages used in these exceptional cases are not the same as those that would be arrived at by using the out-of-bounds A and L values defined for V_PRED and H_PRED. In the case of the leftmost macroblock on the top row of the frame, the 8x8 block is simply filled with the constant value 128.
これらの例外的なケースで使用されている平均は、V_PREDおよびH_PREDで定義されているバウンドAおよびL値を使用して到達するものと同じではないことに注意してください。フレームの一番上の行にある左端のマクロブロックの場合、8x8ブロックは単に定数128で満たされています。
For DC_PRED, apart from the exceptional case of the top-left macroblock, we are averaging either 16 or 8 pixel values to get a single prediction value that fills the 8x8 block. The rounding is done as follows:
DC_PREDの場合、左上マクロブロックの例外的なケースとは別に、16ピクセル値または8ピクセル値のいずれかを平均して、8x8ブロックを埋める単一の予測値を取得しています。丸めは次のように行われます。
---- Begin code block --------------------------------------
int sum; /* sum of 8 or 16 pixels at (at least) 16-bit precision */
int shf; /* base 2 logarithm of the number of pixels (3 or 4) */
Pixel DCvalue = (sum + (1 << (shf-1))) >> shf;
---- End code block ----------------------------------------
Because the summands are all valid pixels, no "clamp" is necessary in the calculation of DCvalue.
summandsはすべて有効なピクセルであるため、dcvalueの計算では「クランプ」は必要ありません。
The remaining "True Motion" (TM_PRED) chroma mode gets its name from an older technique of video compression used by On2 Technologies, to which it bears some relation. In addition to the row "A" and column "L", TM_PRED uses the pixel "P" above and to the left of the chroma block.
残りの「True Motion」（TM_PRED）Chromaモードは、On2テクノロジーが使用する古いビデオ圧縮のテクニックからその名前を取得し、その関係にあります。行「A」と列「L」に加えて、TM_PREDはクロマブロックの上と左側にピクセル "P"を使用します。
The following figure gives an example of how TM_PRED works:
次の図は、TM_PREDがどのように機能するかの例を示しています。
---- Begin code block --------------------------------------
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| P | A0 | A1 | A2 | A3 | A4 | A5 | A6 | A7 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| L0 | X00 | X01 | X02 | X03 | X04 | X05 | X06 | X07 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| L1 | X10 | X11 | X12 | X13 | X14 | X15 | X16 | X17 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| L2 | X20 | X21 | X22 | X23 | X24 | X25 | X26 | X27 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| L3 | X30 | X31 | X32 | X33 | X34 | X35 | X36 | X37 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| L4 | X40 | X41 | X42 | X43 | X44 | X45 | X46 | X47 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| L5 | X50 | X51 | X52 | X53 | X54 | X55 | X56 | X57 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| L6 | X60 | X61 | X62 | X63 | X64 | X65 | X66 | X67 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| L7 | X70 | X71 | X72 | X73 | X74 | X75 | X76 | X77 |
|-----|-----|-----|-----|-----|-----|-----|-----|-----|
---- End code block ----------------------------------------
Where P, As, and Ls represent reconstructed pixel values from previously coded blocks, and X00 through X77 represent predicted values for the current block. TM_PRED uses the following equation to calculate X_ij:
ここで、P、AS、およびLSは、以前にコード化されたブロックからの再構築されたピクセル値を表し、X00からX77は現在のブロックの予測値を表します。TM_PREDは、次の方程式を使用してX_IJを計算します。
X_ij = L_i + A_j - P (i, j=0, 1, 2, 3)
The exact algorithm is as follows:
正確なアルゴリズムは次のとおりです。
---- Begin code block --------------------------------------
void TMpred(
Pixel b[8][8], /* chroma (U or V) prediction block */
const Pixel A[8], /* row of already-constructed pixels
above block */
const Pixel L[8], /* column of "" just to the left of
block */
const Pixel P /* pixel just to the left of A and
above L*/
) {
int r = 0; /* row */
do {
int c = 0; /* column */
do {
b[r][c] = clamp255(L[r]+ A[c] - P);
} while (++c < 8);
} while (++r < 8);
}
---- End code block ----------------------------------------
Note that the process could equivalently be described as propagating the vertical differences between pixels in L (starting from P), using the pixels from A to start each column.
このプロセスは、Aからピクセルを使用して各列のピクセルを使用して、L（Pから開始）のピクセル間の垂直の違いを伝播するものとして同等に説明できることに注意してください。
An implementation of chroma intra-prediction may be found in the reference decoder file predict.c (Section 20.14).
Chroma Intraの予測の実装は、参照デコーダーファイルPredict.c（セクション20.14）に記載されている場合があります。
Unlike DC_PRED, for macroblocks on the top row or left edge, TM_PRED does use the out-of-bounds values of 127 and 129 (respectively) defined for V_PRED and H_PRED.
DC_PREDとは異なり、一番上の行または左端のマクロブロックの場合、TM_PREDは、V_PREDおよびH_PREDに対して定義された127および129（それぞれ）のアウトオブバウンド値を使用します。
The prediction processes for the first four 16x16 luma modes (DC_PRED, V_PRED, H_PRED, and TM_PRED) are essentially identical to the corresponding chroma prediction processes described above, the only difference being that we are predicting a single 16x16 luma block instead of two 8x8 chroma blocks.
最初の4つの16x16 LUMAモード（DC_PRED、V_PRED、H_PRED、およびTM_PRED）の予測プロセスは、上記の対応するクロマ予測プロセスと本質的に同一です。ブロック。
Thus, the row "A" and column "L" here contain 16 pixels, the DC prediction is calculated using 16 or 32 pixels (and shf is 4 or 5), and we of course fill the entire prediction buffer, that is, 16 rows (or columns) containing 16 pixels each. The reference implementation of 16x16 luma prediction is also in predict.c.
したがって、ここでは行「A」と列「L」には16ピクセルが含まれ、DC予測には16ピクセルまたは32ピクセル（およびSHFは4または5）を使用して計算され、もちろん予測バッファー全体、つまり16を埋めます。それぞれ16ピクセルを含む行（または列）。16x16 LUMA予測の参照実装もPredict.cにあります。
In the remaining luma mode (B_PRED), each 4x4 Y subblock is independently predicted using one of ten modes (listed, along with their encodings, in Section 11).
残りのLUMAモード（B_PRED）では、各4x4 Yサブブロックは、10個のモードのいずれかを使用して独立して予測されます（セクション11のエンコーディングとともにリストされています）。
Also, unlike the full-macroblock modes already described, some of the subblock modes use prediction pixels above and to the right of the current subblock. In detail, each 4x4 subblock "B" is predicted using (at most) the 4-pixel column "L" immediately to the left of B and the 8-pixel row "A" immediately above B, consisting of the 4 pixels above B followed by the 4 adjacent pixels above and to the right of B, together with the single pixel "P" immediately to the left of A (and immediately above L).
また、すでに説明されているフルマクロブロックモードとは異なり、一部のサブブロックモードでは、現在のサブブロックの右側と右側に予測ピクセルを使用しています。詳細には、各4x4サブブロック「B」は、（せいぜい）4ピクセル列「L」をBの左側にすぐに使用して予測され、8ピクセルの行「A」はBのすぐ上にあり、Bの上の4ピクセルの上の4ピクセルで構成されています。続いて、Bの上と右側の4つの隣接するピクセルと、Aの左側（およびLのすぐ上）の単一ピクセル「P」とともに続きます。
For the purpose of subblock intra-prediction, the pixels immediately to the left and right of a pixel in a subblock are the same as the pixels immediately to the left and right of the corresponding pixel in the frame buffer "F". Vertical offsets behave similarly: The above row A lies immediately above B in F, and the adjacent pixels in the left column L are separated by a single row in F.
サブブロック内予測の目的のために、サブブロックのピクセルの左右のピクセルは、フレームバッファー「F」の対応するピクセルの左右のピクセルと同じです。垂直オフセットも同様に動作します。上記の行AはFのBのすぐ上にあり、左列Lの隣接するピクセルはFの単一行で分離されます。
Because entire macroblocks (as opposed to their constituent subblocks) are reconstructed in raster-scan order, for subblocks lying along the right edge (and not along the top row) of the current macroblock, the four "extra" prediction pixels in A above and to the right of B have not yet actually been constructed.
マクロブロック全体（構成要素のサブブロックとは対照的に）は、現在のマクロブロックの右端に沿って（そして一番上の列に沿ってではない）サブブロックのために、ラスタースキャンの順序で再構築されているため、上の4つの「エクストラ」予測ピクセルとBの右側にはまだ実際には構築されていません。
Subblocks 7, 11, and 15 are affected. All three of these subblocks use the same extra pixels as does subblock 3 (at the upper right corner of the macroblock), namely the 4 pixels immediately above and to the right of subblock 3. Writing (R,C) for a frame buffer position offset from the upper left corner of the current macroblock by R rows and C columns, the extra pixels for all the right-edge subblocks (3, 7, 11, and 15) are at positions (-1,16), (-1,17), (-1,18), and (-1,19). For the rightmost macroblock in each macroblock row except the top row, the extra pixels shall use the same value as the pixel at position (-1,15), which is the rightmost visible pixel on the line immediately above the macroblock row. For the top macroblock row, all the extra pixels assume a value of 127.
サブブロック7、11、および15は影響を受けます。これらの3つのサブブロックはすべて、サブブロック3（マクロブロックの右上隅）と同じ追加ピクセルを使用します。現在のマクロブロックの左上隅からrowsとc列によってオフセットされ、すべての右端のサブブロック（3、7、11、および15の追加ピクセルが位置（-1,16）にあります（-1、17）、（-1,18）、および（-1,19）。各マクロブロック行の右端のマクロブロックの場合、上の行を除くマクロブロックの行は、エキストラピクセルが位置のピクセルと同じ値（-1,15）と同じ値を使用します。トップマクロブロック行の場合、すべての追加ピクセルは127の値を想定しています。
The details of the prediction modes are most easily described in code.
予測モードの詳細は、コードで最も簡単に説明されています。
---- Begin code block --------------------------------------
/* Result pixels are often averages of two or three predictor
pixels. The following subroutines are used to calculate
these averages. Because the arguments are valid pixels, no
clamping is necessary. An actual implementation would
probably use inline functions or macros. */
/* Compute weighted average centered at y w/adjacent x, z */
Pixel avg3(Pixel x, Pixel y, Pixel z) {
return (x + y + y + z + 2) >> 2;}
/* Weighted average of 3 adjacent pixels centered at p */
Pixel avg3p(const Pixel *p) { return avg3(p[-1], p[0], p[1]);}
/* Simple average of x and y */
Pixel avg2(Pixel x, Pixel y) { return (x + y + 1) >> 1;}
/* Average of p[0] and p[1] may be considered to be a synthetic
pixel lying between the two, that is, one half-step past p. */
Pixel avg2p(const Pixel *p) { return avg2(p[0], p[1]);}
void subblock_intra_predict(
Pixel B[4][4], /* Y subblock prediction buffer */
const Pixel *A, /* A[0]...A[7] = above row, A[-1] = P */
const Pixel *L, /* L[0]...L[3] = left column, L[-1] = P */
intra_bmode mode /* enum is in Section 11.2 */
) {
Pixel E[9]; /* 9 already-constructed edge pixels */
E[0] = L[3]; E[1] = L[2]; E[2] = L[1]; E[3] = L[0];
E[4] = A[-1]; /* == L[-1] == P */
E[5] = A[0]; E[6] = A[1]; E[7] = A[2]; E[8] = A[3];
switch(mode) {
/* First four modes are similar to corresponding
full-block modes. */
case B_DC_PRED:
{
int v = 4; /* DC sum/avg, 4 is rounding adjustment */
int i = 0; do { v += A[i] + L[i];} while (++i < 4);
v >>= 3; /* averaging 8 pixels */
i = 0; do { /* fill prediction buffer with constant DC
value */
int j = 0; do { B[i][j] = v;} while (++j < 4);
} while (++i < 4);
break;
}
case B_TM_PRED: /* just like 16x16 TM_PRED */
{
int r = 0; do {
int c = 0; do {
B[r][c] = clamp255(L[r] + A[c] - A[-1]);
} while (++c < 4);
} while (++r < 4);
break;
}
case B_VE_PRED: /* like 16x16 V_PRED except using averages */
{
int c = 0; do { /* all 4 rows = smoothed top row */
B[0][c] = B[1][c] = B[2][c] = B[3][c] = avg3p(A + c);
} while (++c < 4);
break;
}
case B_HE_PRED: /* like 16x16 H_PRED except using averages */
{
/* Bottom row is exceptional because L[4] does not exist */
int v = avg3(L[2], L[3], L[3]);
int r = 3; while (1) { /* all 4 columns = smoothed left
column */
B[r][0] = B[r][1] = B[r][2] = B[r][3] = v;
if (--r < 0)
break;
v = avg3p(L + r); /* upper 3 rows use average of
3 pixels */
}
break;
}
/* The remaining six "diagonal" modes subdivide the
prediction buffer into diagonal lines. All the pixels
on each line are assigned the same value; this value is
(a smoothed or synthetic version of) an
already-constructed predictor value lying on the same
line. For clarity, in the comments, we express the
positions of these predictor pixels relative to the
upper left corner of the destination array B.
These modes are unique to subblock prediction and have
no full-block analogs. The first two use lines at
+|- 45 degrees from horizontal (or, equivalently,
vertical), that is, lines whose slopes are +|- 1. */
case B_LD_PRED: /* southwest (left and down) step =
(-1, 1) or (1,-1) */
/* avg3p(A + j) is the "smoothed" pixel at (-1,j) */
B[0][0] = avg3p(A + 1);
B[0][1] = B[1][0] = avg3p(A + 2);
B[0][2] = B[1][1] = B[2][0] = avg3p(A + 3);
B[0][3] = B[1][2] = B[2][1] = B[3][0] = avg3p(A + 4);
B[1][3] = B[2][2] = B[3][1] = avg3p(A + 5);
B[2][3] = B[3][2] = avg3p(A + 6);
B[3][3] = avg3(A[6], A[7], A[7]); /* A[8] does not exist */
break;
case B_RD_PRED: /* southeast (right and down) step =
(1,1) or (-1,-1) */
B[3][0] = avg3p(E + 1); /* predictor is from (2, -1) */
B[3][1] = B[2][0] = avg3p(E + 2); /* (1, -1) */
B[3][2] = B[2][1] = B[1][0] = avg3p(E + 3); /* (0, -1) */
B[3][3] = B[2][2] = B[1][1] = B[0][0] =
avg3p(E + 4); /* (-1, -1) */
B[2][3] = B[1][2] = B[0][1] = avg3p(E + 5); /* (-1, 0) */
B[1][3] = B[0][2] = avg3p(E + 6); /* (-1, 1) */
B[0][3] = avg3p(E + 7); /* (-1, 2) */
break;
/* The remaining 4 diagonal modes use lines whose slopes are
+|- 2 and +|- 1/2. The angles of these lines are roughly
+|- 27 degrees from horizontal or vertical.
Unlike the 45 degree diagonals, here we often need to
"synthesize" predictor pixels midway between two actual
predictors using avg2p(p), which we think of as returning
the pixel "at" p[1/2]. */
case B_VR_PRED: /* SSE (vertical right) step =
(2,1) or (-2,-1) */
B[3][0] = avg3p(E + 2); /* predictor is from (1, -1) */
B[2][0] = avg3p(E + 3); /* (0, -1) */
B[3][1] = B[1][0] = avg3p(E + 4); /* (-1, -1) */
B[2][1] = B[0][0] = avg2p(E + 4); /* (-1, -1/2) */
B[3][2] = B[1][1] = avg3p(E + 5); /* (-1, 0) */
B[2][2] = B[0][1] = avg2p(E + 5); /* (-1, 1/2) */
B[3][3] = B[1][2] = avg3p(E + 6); /* (-1, 1) */
B[2][3] = B[0][2] = avg2p(E + 6); /* (-1, 3/2) */
B[1][3] = avg3p(E + 7); /* (-1, 2) */
B[0][3] = avg2p(E + 7); /* (-1, 5/2) */
break;
case B_VL_PRED: /* SSW (vertical left) step =
(2,-1) or (-2,1) */
B[0][0] = avg2p(A); /* predictor is from (-1, 1/2) */
B[1][0] = avg3p(A + 1); /* (-1, 1) */
B[2][0] = B[0][1] = avg2p(A + 1); /* (-1, 3/2) */
B[1][1] = B[3][0] = avg3p(A + 2); /* (-1, 2) */
B[2][1] = B[0][2] = avg2p(A + 2); /* (-1, 5/2) */
B[3][1] = B[1][2] = avg3p(A + 3); /* (-1, 3) */
B[2][2] = B[0][3] = avg2p(A + 3); /* (-1, 7/2) */
B[3][2] = B[1][3] = avg3p(A + 4); /* (-1, 4) */
/* Last two values do not strictly follow the pattern. */
B[2][3] = avg3p(A + 5); /* (-1, 5) [avg2p(A + 4) =
(-1,9/2)] */
B[3][3] = avg3p(A + 6); /* (-1, 6) [avg3p(A + 5) =
(-1,5)] */
break;
case B_HD_PRED: /* ESE (horizontal down) step =
(1,2) or (-1,-2) */
B[3][0] = avg2p(E); /* predictor is from (5/2, -1) */
B[3][1] = avg3p(E + 1); /* (2, -1) */
B[2][0] = B[3][2] = svg2p(E + 1); /* ( 3/2, -1) */
B[2][1] = B[3][3] = avg3p(E + 2); /* ( 1, -1) */
B[2][2] = B[1][0] = avg2p(E + 2); /* ( 1/2, -1) */
B[2][3] = B[1][1] = avg3p(E + 3); /* ( 0, -1) */
B[1][2] = B[0][0] = avg2p(E + 3); /* (-1/2, -1) */
B[1][3] = B[0][1] = avg3p(E + 4); /* ( -1, -1) */
B[0][2] = avg3p(E + 5); /* (-1, 0) */
B[0][3] = avg3p(E + 6); /* (-1, 1) */
break;
case B_HU_PRED: /* ENE (horizontal up) step = (1,-2)
or (-1,2) */
B[0][0] = avg2p(L); /* predictor is from (1/2, -1) */
B[0][1] = avg3p(L + 1); /* (1, -1) */
B[0][2] = B[1][0] = avg2p(L + 1); /* (3/2, -1) */
B[0][3] = B[1][1] = avg3p(L + 2); /* ( 2, -1) */
B[1][2] = B[2][0] = avg2p(L + 2); /* (5/2, -1) */
B[1][3] = B[2][1] = avg3(L[2], L[3], L[3]); /* (3, -1) */
/* Not possible to follow pattern for much of the bottom
row because no (nearby) already-constructed pixels lie
on the diagonals in question. */
B[2][2] = B[2][3] = B[3][0] = B[3][1] = B[3][2] = B[3][3]
= L[3];
}
}
---- End code block ----------------------------------------
The reference decoder implementation of subblock intra-prediction may be found in predict.c (Section 20.14).
サブブロック内予測の参照デコーダー実装は、Predict.C（セクション20.14）に記載されている場合があります。
The second data partition consists of an encoding of the quantized DCT (and WHT) coefficients of the residue signal. As discussed in the format overview (Section 2), for each macroblock, the residue is added to the (intra- or inter-generated) prediction buffer to produce the final (except for loop filtering) reconstructed macroblock.
2番目のデータパーティションは、残基信号の量子化されたDCT（およびWHT）係数のエンコードで構成されています。フォーマットの概要（セクション2）で説明したように、各マクロブロックについて、残基は（ループフィルタリングを除く）再構築されたマクロブロックを生成するために（生成または相互に生成された）予測バッファーに追加されます。
VP8 works exclusively with 4x4 DCTs and WHTs, applied to the 24 (or 25 with the Y2 subblock) 4x4 subblocks of a macroblock. The ordering of macroblocks within any of the "residue" partitions in general follows the same raster scan as used in the first "prediction" partition.
VP8は、マクロブロックの4x4サブブロック24（またはY2サブブロックで25）に適用される4x4 DCTおよびWHTSのみで機能します。一般に、「残基」パーティションのいずれか内でのマクロブロックの順序は、最初の「予測」パーティションで使用されたのと同じラスタースキャンに従います。
For all intra- and inter-prediction modes apart from B_PRED (intra: whose Y subblocks are independently predicted) and SPLITMV (inter), each macroblock's residue record begins with the Y2 component of the residue, coded using a WHT. B_PRED and SPLITMV coded macroblocks omit this WHT and specify the 0th DCT coefficient in each of the 16 Y subblocks.
B_PRED（Yサブブロックが独立して予測されている）とSplitMV（Inter）を除いて、すべての予測および相間モードについて、各マクロブロックの残基レコードは、WHTを使用してコード化された残基のY2成分から始まります。B_PREDおよびSPLITMVコード化されたマクロブロックは、このWHTを省略し、16 Yの各サブブロックで0番目のDCT係数を指定します。
After the optional Y2 block, the residue record continues with 16 DCTs for the Y subblocks, followed by 4 DCTs for the U subblocks, ending with 4 DCTs for the V subblocks. The subblocks occur in the usual order.
オプションのY2ブロックの後、残差記録はYサブブロックの16 DCTで続き、続いてUサブブロックに4 dCTが続き、Vサブブロックの4つのDCTで終了します。サブブロックは通常の順序で発生します。
The DCTs and WHT are tree-coded using a 12-element alphabet whose members we call "tokens". Except for the end-of-block token (which sets the remaining subblock coefficients to zero and is followed by the next block), each token (sometimes augmented with data immediately following the token) specifies the value of the single coefficient at the current (implicit) position and is followed by a token applying to the next (implicit) position.
DCTとWHTは、メンバーが「トークン」と呼ぶ12要素のアルファベットを使用してツリーコードされています。ブロック終了トークン（残りのサブブロック係数をゼロに設定し、次のブロックが続く）を除き、各トークン（トークンの直後のデータで拡張されることもあります）は、電流の単一係数の値を指定します（暗黙的）位置に続いて、次の（暗黙の）位置に適用されるトークンが続きます。
For all the Y and chroma subblocks, the ordering of the coefficients follows a so-called zig-zag order. DCTs begin at coefficient 1 if Y2 is present, and begin at coefficient 0 if Y2 is absent. The WHT for a Y2 subblock always begins at coefficient 0.
すべてのYおよびChromaサブブロックについて、係数の順序は、いわゆるジグザグ順序に従います。dctsは、y2が存在する場合は係数1で始まり、y2が存在しない場合は係数0で開始します。Y2サブブロックのWHTは常に係数0で始まります。
If the flag within macroblock (MB) MODE_INFO indicates that a macroblock does not have any non-zero coefficients, the decoding process of DCT coefficients is skipped for the macroblock.
Macroblock（MB）Mode_Info内のフラグがマクロブロックにゼロ係数がないことを示している場合、DCT係数のデコードプロセスがマクロブロック用にスキップされます。
The coding of coefficient tokens is the same for the DCT and WHT, and for the remainder of this section "DCT" should be taken to mean either DCT or WHT.
係数トークンのコーディングはDCTおよびWHTで同じであり、このセクションの残りの部分では、「DCT」はDCTまたはWHTのいずれかを意味すると考えられる必要があります。
All tokens (except end-of-block) specify either a single unsigned value or a range of unsigned values (immediately) followed by a simple probabilistic encoding of the offset of the value from the base of that range.
すべてのトークン（ブロックの終了を除く）は、単一の符号なしの値または符号なしの値の範囲（すぐに）のいずれかを指定し、その後、その範囲のベースからの値のオフセットの単純な確率エンコードが続きます。
Non-zero values (of either type) are then followed by a flag indicating the sign of the coded value (negative if 1, positive if 0).
次に、非ゼロ値（いずれかのタイプの）に続いて、コード化された値の符号を示すフラグが続きます（負の場合は負、0の場合は正です）。
Below are the tokens and decoding tree.
以下は、トークンとデコードツリーです。
---- Begin code block --------------------------------------
typedef enum
{
DCT_0, /* value 0 */
DCT_1, /* 1 */
DCT_2, /* 2 */
DCT_3, /* 3 */
DCT_4, /* 4 */
dct_cat1, /* range 5 - 6 (size 2) */
dct_cat2, /* 7 - 10 (4) */
dct_cat3, /* 11 - 18 (8) */
dct_cat4, /* 19 - 34 (16) */
dct_cat5, /* 35 - 66 (32) */
dct_cat6, /* 67 - 2048 (1982) */
dct_eob, /* end of block */
num_dct_tokens /* 12 */
}
dct_token;
const tree_index coeff_tree [2 * (num_dct_tokens - 1)] =
{
-dct_eob, 2, /* eob = "0" */
-DCT_0, 4, /* 0 = "10" */
-DCT_1, 6, /* 1 = "110" */
8, 12,
-DCT_2, 10, /* 2 = "11100" */
-DCT_3, -DCT_4, /* 3 = "111010", 4 = "111011" */
14, 16,
-dct_cat1, -dct_cat2, /* cat1 = "111100",
cat2 = "111101" */
18, 20,
-dct_cat3, -dct_cat4, /* cat3 = "1111100",
cat4 = "1111101" */
-dct_cat5, -dct_cat6 /* cat4 = "1111110",
cat4 = "1111111" */
};
---- End code block ----------------------------------------
In general, all DCT coefficients are decoded using the same tree. However, if the preceding coefficient is a DCT_0, decoding will skip the first branch, since it is not possible for dct_eob to follow a DCT_0.
一般に、すべてのDCT係数は同じツリーを使用してデコードされます。ただし、前述の係数がDCT_0の場合、DCT_EOBがDCT_0に従うことは不可能なため、デコードは最初のブランチをスキップします。
The tokens dct_cat1 ... dct_cat6 specify ranges of unsigned values, the value within the range being formed by adding an unsigned offset (whose width is 1, 2, 3, 4, 5, or 11 bits, respectively) to the base of the range, using the following algorithm and fixed probability tables.
トークンDCT_CAT1 ... DCT_CAT6は、署名されていない値の範囲を指定します。範囲内の値は、署名されていないオフセット（幅がそれぞれ1、2、3、4、5、または11ビット）を追加することで形成されます。範囲、次のアルゴリズムと固定確率表を使用します。
---- Begin code block --------------------------------------
uint DCTextra(bool_decoder *d, const Prob *p)
{
uint v = 0;
do { v += v + read_bool(d, *p);} while (*++p);
return v;
}
const Prob Pcat1[] = { 159, 0};
const Prob Pcat2[] = { 165, 145, 0};
const Prob Pcat3[] = { 173, 148, 140, 0};
const Prob Pcat4[] = { 176, 155, 140, 135, 0};
const Prob Pcat5[] = { 180, 157, 141, 134, 130, 0};
const Prob Pcat6[] =
{ 254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129, 0};
---- End code block ----------------------------------------
If v -- the unsigned value decoded using the coefficient tree, possibly augmented by the process above -- is non-zero, its sign is set by simply reading a flag:
v-上記のプロセスによって増強される可能性がある係数ツリーを使用してデコードされていない符号の値がゼロではなく、その標識はフラグを読み取るだけで設定されます。
---- Begin code block --------------------------------------
if (read_bool(d, 128))
v = -v;
---- End code block ----------------------------------------
The probability specification for the token tree (unlike that for the "extra bits" described above) is rather involved. It uses three pieces of context to index a large probability table, the contents of which may be incrementally modified in the frame header. The full (non-constant) probability table is laid out as follows.
トークンツリーの確率仕様（上記の「余分なビット」とは異なり）はかなり関与しています。3つのコンテキストを使用して、大きな確率表にインデックスを付けます。その内容は、フレームヘッダーで徐々に変更される場合があります。完全な（非対照）確率表は次のようにレイアウトされています。
---- Begin code block --------------------------------------
Prob coeff_probs [4] [8] [3] [num_dct_tokens-1];
prob coeff_probs [4] [8] [3] [num_dct_tokens-1];
---- End code block ----------------------------------------
Working from the outside in, the outermost dimension is indexed by the type of plane being decoded:
外側から作業すると、最も外側の寸法は、デコードされる平面のタイプによってインデックス付けされます。
o 0 - Y beginning at coefficient 1 (i.e., Y after Y2)
o 0 -y係数1から始まる（つまり、y2の後のy）
o 1 - Y2
o 1 -Y2
o 2 - U or V
o 2 -uまたはv
o 3 - Y beginning at coefficient 0 (i.e., Y in the absence of Y2).
o 3 -Y係数0（つまり、y2の非存在下でy）から始まります。
The next dimension is selected by the position of the coefficient being decoded. That position, c, steps by ones up to 15, starting from zero for block types 1, 2, or 3 and starting from one for block type 0. The second array index is then
次の寸法は、デコードされている係数の位置によって選択されます。その位置cは、ブロックタイプ1、2、または3のゼロから始まり、ブロックタイプ0の1から始まる最大15までのステップで、2番目の配列インデックスは次のとおりです。
---- Begin code block --------------------------------------
coeff_bands [c]
coeff_bands [c]
---- End code block ----------------------------------------
Where:
ただし：
---- Begin code block --------------------------------------
const int coeff_bands [16] = {
0, 1, 2, 3, 6, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7
};
---- End code block ----------------------------------------
is a fixed mapping of position to "band".
「バンド」への位置の固定マッピングです。
The third dimension is the trickiest. Roughly speaking, it measures the "local complexity" or extent to which nearby coefficients are non-zero.
3番目の次元が最もトリッキーです。大まかに言えば、それは「局所的な複雑さ」または近くの係数がゼロではない程度を測定します。
For the first coefficient (DC, unless the block type is 0), we consider the (already encoded) blocks within the same plane (Y2, Y, U, or V) above and to the left of the current block. The context index is then the number (0, 1, or 2) of these blocks that had at least one non-zero coefficient in their residue record. Specifically for Y2, because macroblocks above and to the left may or may not have a Y2 block, the block above is determined by the most recent macroblock in the same column that has a Y2 block, and the block to the left is determined by the most recent macroblock in the same row that has a Y2 block.
最初の係数（DC、ブロックタイプが0でない限り）の場合、現在のブロックの上および左側の同じ平面（Y2、Y、U、またはV）内の（既にエンコードされた）ブロックを検討します。コンテキストインデックスは、残基レコードに少なくとも1つの非ゼロ係数があるこれらのブロックの数（0、1、または2）です。特にY2の場合、マクロブロックの上と左にはY2ブロックがある場合とそうでない場合があるため、上記のブロックは、Y2ブロックを持つ同じ列の最新のマクロブロックによって決定され、左からブロックが決定されます。Y2ブロックを備えた同じ行に最新のマクロブロック。
Beyond the first coefficient, the context index is determined by the absolute value of the most recently decoded coefficient (necessarily within the current block) and is 0 if the last coefficient was a zero, 1 if it was plus or minus one, and 2 if its absolute value exceeded one.
最初の係数を超えて、コンテキストインデックスは、直近のデコードされた係数の絶対値（必然的に現在のブロック内）によって決定され、最後の係数がゼロの場合は0、プラスまたはマイナスの場合は1、2その絶対値は1を超えました。
Note that the intuitive meaning of this measure changes as coefficients are decoded. For example, prior to the first token, a zero means that the neighbors are empty, suggesting that the current block may also be empty. After the first token, because an end-of-block token must have at least one non-zero value before it, a zero means that we just decoded a zero and hence guarantees that a non-zero coefficient will appear later in this block. However, this shift in meaning is perfectly okay because the complete context depends also on the coefficient band (and since band 0 is occupied exclusively by position 0).
係数がデコードされると、このメジャーの直感的な意味が変化することに注意してください。たとえば、最初のトークンの前に、ゼロは隣人が空であることを意味し、現在のブロックも空である可能性があることを示唆しています。最初のトークンの後、ブロックの終わりのトークンは少なくとも1つの非ゼロ値を持っている必要があるため、ゼロはゼロを解読しただけであるため、このブロックで非ゼロ係数が後で表示されることを保証します。ただし、完全なコンテキストは係数帯域にも依存するため、この意味の変化は完全に問題ありません（およびバンド0は位置0でのみ占有されているため）。
As with other contexts used by VP8, the "neighboring block" context described here needs a special definition for subblocks lying along the top row or left edge of the frame. These "non-existent" predictors above and to the left of the image are simply taken to be empty -- that is, taken to contain no non-zero coefficients.
VP8が使用する他のコンテキストと同様に、ここで説明する「隣接するブロック」コンテキストには、フレームの一番上の行または左端に沿って横たわっているサブブロックの特別な定義が必要です。これらの「存在しない」画像の左側と左側は、単に空であると見なされます。つまり、ゼロ以外の係数が含まれていないと考えられています。
The residue decoding of each macroblock then requires, in each of two directions (above and to the left), an aggregate coefficient predictor consisting of a single Y2 predictor, two predictors for each of U and V, and four predictors for Y. In accordance with the scan-ordering of macroblocks, a decoder needs to maintain a single "left" aggregate predictor and a row of "above" aggregate predictors.
各マクロブロックの残留デコードには、2つの方向（上および左側）のそれぞれに、単一のY2予測子、uとvのそれぞれの2つの予測因子、およびyの4つの予測因子で構成される凝集係数予測子が必要です。マクロブロックのスキャン順序により、デコーダーは単一の「左」の集約予測子と「上」集約予測子の行を維持する必要があります。
Before decoding any residue, these maintained predictors may simply be cleared, in compliance with the definition of "non-existent" prediction. After each block is decoded, the two predictors referenced by the block are replaced with the (empty or non-empty) state of the block, in preparation for the later decoding of the blocks below and to the right of the block just decoded.
残留物を解読する前に、これらの維持された予測因子は、「存在しない」予測の定義に準拠して、単にクリアされる可能性があります。各ブロックがデコードされた後、ブロックによって参照される2つの予測因子は、ブロックの（空のまたは空の非）状態に置き換えられます。
The fourth, and final, dimension of the token probability array is of course indexed by (half) the position in the token tree structure, as are all tree probability arrays.
トークン確率アレイの4番目の最終的な寸法は、もちろん、すべてのツリー確率アレイと同様に、トークンツリー構造の位置（半分）によってインデックス付けされます。
The pseudocode below illustrates the decoding process. Note that criteria, functions, etc. delimited with ** are either dependent on decoder architecture or are elaborated on elsewhere in this document.
以下の擬似コードは、デコードプロセスを示しています。**で区切られた基準、関数などは、デコーダーアーキテクチャに依存するか、このドキュメントの他の場所で詳しく説明されていることに注意してください。
---- Begin code block --------------------------------------
int block[16] = { 0 }; /* current 4x4 block coeffs */
int firstCoeff = 0;
int plane;
int ctx2;
int ctx3 = 0; /* the 3rd context referred to in above description */
Prob *probTable;
int token;
int sign;
int absValue;
int extraBits;
bool prevCoeffWasZero = false;
bool currentBlockHasCoeffs = false;
/* base coeff abs values per each category, elem #0 is
DCT_VAL_CATEGORY1, * #1 is DCT_VAL_CATEGORY2, etc. */
int categoryBase[6] = { 5, 7, 11, 19, 35, 67 };
/* Determine plane to use */
if ( **current_block_is_Y2_block** ) plane = 0;
else if ( **current_block_is_chroma** ) plane = 2;
else if ( **current_macroblock_has_Y2** ) plane = 1;
else plane = 3;
/* For luma blocks of a "Y2 macroblock" we skip coeff index #0 */
if ( plane == 1 )
firstCoeff++;
/* Determine whether neighbor 4x4 blocks have coefficients.
This is dependent on the plane we are currently decoding;
i.e., we check only coefficients from the same plane as the
current block. */
if ( **left_neighbor_block_has_coefficients(plane)** )
ctx3++;
if ( **above_neighbor_block_has_coefficients(plane)** )
ctx3++;
for( i = firstCoeff; i < 16; ++i )
{
ctx2 = coeff_bands[i];
probTable = coeff_probs[plane][ctx2][ctx3];
/* skip first code (dct_eob) if previous token was DCT_0 */
if ( prevCoeffWasZero )
token = treed_read ( d, **coeff_tree_without_eob**,
probTable );
else
token = treed_read ( d, coeff_tree, probTable );
if ( token == dct_eob ) break;
if（token == dct_eob）break;
if ( token != DCT_0 )
{
currentBlockHasCoeffs = true;
if ( **token_has_extra_bits(token)** )
{
extraBits = DCTextra( token );
absValue =
categoryBase[**token_to_cat_index(token)**] +
extraBits;
}
else
{
absValue = **token_to_abs_value(token)**;
}
sign = read_bool(d, 128);
block[i] = sign ? -absValue : absValue;
}
else
{
absValue = 0;
}
/* Set contexts and stuff for next coeff */
if ( absValue == 0 ) ctx3 = 0;
else if ( absValue == 1 ) ctx3 = 1;
else ctx3 = 2;
prevCoeffWasZero = true;
}
/* Store current block status to decoder internals */
**block_has_coefficients[currentMb][currentBlock]** =
currentBlockHasCoeffs;
---- End code block ----------------------------------------
While we have in fact completely described the coefficient decoding procedure, the reader will probably find it helpful to consult the reference implementation, which can be found in the file tokens.c (Section 20.16).
実際、係数デコード手順については完全に説明しましたが、読者はおそらく、ファイルtokens.c（セクション20.16）にある参照実装を参照することが役立つでしょう。
As mentioned above, the token-decoding probabilities may change from frame to frame. After detection of a key frame, they are of course set to their defaults as shown in Section 13.5; this must occur before decoding the remainder of the header, as both key frames and interframes may adjust these probabilities.
上記のように、トークンゼコードの確率はフレームからフレームに変化する場合があります。キーフレームを検出した後、セクション13.5に示すように、それらはもちろんデフォルトに設定されます。これは、キーフレームとインターフレームの両方がこれらの確率を調整する可能性があるため、ヘッダーの残りをデコードする前に発生する必要があります。
The layout and semantics of the coefficient probability update record (Section I of the frame header) are straightforward. For each position in the coeff_probs array there occurs a fixed-probability bool indicating whether or not the corresponding probability should be updated. If the bool is true, there follows a P(8) replacing that probability. Note that updates are cumulative; that is, a probability updated on one frame is in effect for all ensuing frames until the next key frame, or until the probability is explicitly updated by another frame.
係数確率アップデートレコード（フレームヘッダーのセクションI）のレイアウトとセマンティクスは簡単です。Coeff_Probsアレイの各位置について、対応する確率を更新するかどうかを示す固定能力ブールが発生します。ブールが真の場合、その確率を置き換えるp（8）が続きます。更新は累積的であることに注意してください。つまり、次のキーフレームまで、または別のフレームによって確率が明示的に更新されるまで、1つのフレームで更新される確率が有効です。
The algorithm to effect the foregoing is simple:
前述のアルゴリズムは簡単です。
---- Begin code block --------------------------------------
int i = 0; do {
int j = 0; do {
int k = 0; do {
int t = 0; do {
if (read_bool(d, coeff_update_probs [i] [j] [k] [t]))
coeff_probs [i] [j] [k] [t] = read_literal(d, 8);
} while (++t < num_dct_tokens - 1);
} while (++k < 3);
} while (++j < 8);
} while (++i < 4);
---- End code block ----------------------------------------
The (constant) update probabilities are as follows:
（定数）更新確率は次のとおりです。
---- Begin code block --------------------------------------
const Prob coeff_update_probs [4] [8] [3] [num_dct_tokens-1] =
{
{
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 176, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 223, 241, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{ 249, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 244, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{ 234, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 246, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 239, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 251, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 251, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 253, 255, 254, 255, 255, 255, 255, 255, 255},
{ 250, 255, 254, 255, 254, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
}
},
{
{
{ 217, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 225, 252, 241, 253, 255, 255, 254, 255, 255, 255, 255},
{ 234, 250, 241, 250, 253, 255, 253, 254, 255, 255, 255}
},
{
{ 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 223, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 238, 253, 254, 254, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 249, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 247, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
}
},
{
{
{ 186, 251, 250, 255, 255, 255, 255, 255, 255, 255, 255},
{ 234, 251, 244, 254, 255, 255, 255, 255, 255, 255, 255},
{ 251, 251, 243, 253, 254, 255, 254, 255, 255, 255, 255}
},
{
{ 255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 236, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 251, 253, 253, 254, 254, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
}
},
{
{
{ 248, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 250, 254, 252, 254, 255, 255, 255, 255, 255, 255, 255},
{ 248, 254, 249, 253, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 246, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 252, 254, 251, 254, 254, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{ 248, 254, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 253, 255, 254, 254, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 251, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 245, 251, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 253, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 251, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 252, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 249, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
}
}
};
---- End code block ----------------------------------------
The default token probabilities are as follows.
デフォルトのトークン確率は次のとおりです。
---- Begin code block --------------------------------------
const Prob default_coeff_probs [4] [8] [3] [num_dct_tokens - 1] =
{
{
{
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
},
{
{ 253, 136, 254, 255, 228, 219, 128, 128, 128, 128, 128},
{ 189, 129, 242, 255, 227, 213, 255, 219, 128, 128, 128},
{ 106, 126, 227, 252, 214, 209, 255, 255, 128, 128, 128}
},
{
{ 1, 98, 248, 255, 236, 226, 255, 255, 128, 128, 128},
{ 181, 133, 238, 254, 221, 234, 255, 154, 128, 128, 128},
{ 78, 134, 202, 247, 198, 180, 255, 219, 128, 128, 128}
},
{
{ 1, 185, 249, 255, 243, 255, 128, 128, 128, 128, 128},
{ 184, 150, 247, 255, 236, 224, 128, 128, 128, 128, 128},
{ 77, 110, 216, 255, 236, 230, 128, 128, 128, 128, 128}
},
{
{ 1, 101, 251, 255, 241, 255, 128, 128, 128, 128, 128},
{ 170, 139, 241, 252, 236, 209, 255, 255, 128, 128, 128},
{ 37, 116, 196, 243, 228, 255, 255, 255, 128, 128, 128}
},
{
{ 1, 204, 254, 255, 245, 255, 128, 128, 128, 128, 128},
{ 207, 160, 250, 255, 238, 128, 128, 128, 128, 128, 128},
{ 102, 103, 231, 255, 211, 171, 128, 128, 128, 128, 128}
},
{
{ 1, 152, 252, 255, 240, 255, 128, 128, 128, 128, 128},
{ 177, 135, 243, 255, 234, 225, 128, 128, 128, 128, 128},
{ 80, 129, 211, 255, 194, 224, 128, 128, 128, 128, 128}
},
{
{ 1, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 246, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 255, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
}
},
{
{
{ 198, 35, 237, 223, 193, 187, 162, 160, 145, 155, 62},
{ 131, 45, 198, 221, 172, 176, 220, 157, 252, 221, 1},
{ 68, 47, 146, 208, 149, 167, 221, 162, 255, 223, 128}
},
{
{ 1, 149, 241, 255, 221, 224, 255, 255, 128, 128, 128},
{ 184, 141, 234, 253, 222, 220, 255, 199, 128, 128, 128},
{ 81, 99, 181, 242, 176, 190, 249, 202, 255, 255, 128}
},
{
{ 1, 129, 232, 253, 214, 197, 242, 196, 255, 255, 128},
{ 99, 121, 210, 250, 201, 198, 255, 202, 128, 128, 128},
{ 23, 91, 163, 242, 170, 187, 247, 210, 255, 255, 128}
},
{
{ 1, 200, 246, 255, 234, 255, 128, 128, 128, 128, 128},
{ 109, 178, 241, 255, 231, 245, 255, 255, 128, 128, 128},
{ 44, 130, 201, 253, 205, 192, 255, 255, 128, 128, 128}
},
{
{ 1, 132, 239, 251, 219, 209, 255, 165, 128, 128, 128},
{ 94, 136, 225, 251, 218, 190, 255, 255, 128, 128, 128},
{ 22, 100, 174, 245, 186, 161, 255, 199, 128, 128, 128}
},
{
{ 1, 182, 249, 255, 232, 235, 128, 128, 128, 128, 128},
{ 124, 143, 241, 255, 227, 234, 128, 128, 128, 128, 128},
{ 35, 77, 181, 251, 193, 211, 255, 205, 128, 128, 128}
},
{
{ 1, 157, 247, 255, 236, 231, 255, 255, 128, 128, 128},
{ 121, 141, 235, 255, 225, 227, 255, 255, 128, 128, 128},
{ 45, 99, 188, 251, 195, 217, 255, 224, 128, 128, 128}
},
{
{ 1, 1, 251, 255, 213, 255, 128, 128, 128, 128, 128},
{ 203, 1, 248, 255, 255, 128, 128, 128, 128, 128, 128},
{ 137, 1, 177, 255, 224, 255, 128, 128, 128, 128, 128}
}
},
{
{
{ 253, 9, 248, 251, 207, 208, 255, 192, 128, 128, 128},
{ 175, 13, 224, 243, 193, 185, 249, 198, 255, 255, 128},
{ 73, 17, 171, 221, 161, 179, 236, 167, 255, 234, 128}
},
{
{ 1, 95, 247, 253, 212, 183, 255, 255, 128, 128, 128},
{ 239, 90, 244, 250, 211, 209, 255, 255, 128, 128, 128},
{ 155, 77, 195, 248, 188, 195, 255, 255, 128, 128, 128}
},
{
{ 1, 24, 239, 251, 218, 219, 255, 205, 128, 128, 128},
{ 201, 51, 219, 255, 196, 186, 128, 128, 128, 128, 128},
{ 69, 46, 190, 239, 201, 218, 255, 228, 128, 128, 128}
},
{
{ 1, 191, 251, 255, 255, 128, 128, 128, 128, 128, 128},
{ 223, 165, 249, 255, 213, 255, 128, 128, 128, 128, 128},
{ 141, 124, 248, 255, 255, 128, 128, 128, 128, 128, 128}
},
{
{ 1, 16, 248, 255, 255, 128, 128, 128, 128, 128, 128},
{ 190, 36, 230, 255, 236, 255, 128, 128, 128, 128, 128},
{ 149, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{
{ 1, 226, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 247, 192, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 240, 128, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{
{ 1, 134, 252, 255, 255, 128, 128, 128, 128, 128, 128},
{ 213, 62, 250, 255, 255, 128, 128, 128, 128, 128, 128},
{ 55, 93, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
}
},
{
{
{ 202, 24, 213, 235, 186, 191, 220, 160, 240, 175, 255},
{ 126, 38, 182, 232, 169, 184, 228, 174, 255, 187, 128},
{ 61, 46, 138, 219, 151, 178, 240, 170, 255, 216, 128}
},
{
{ 1, 112, 230, 250, 199, 191, 247, 159, 255, 255, 128},
{ 166, 109, 228, 252, 211, 215, 255, 174, 128, 128, 128},
{ 39, 77, 162, 232, 172, 180, 245, 178, 255, 255, 128}
},
{
{ 1, 52, 220, 246, 198, 199, 249, 220, 255, 255, 128},
{ 124, 74, 191, 243, 183, 193, 250, 221, 255, 255, 128},
{ 24, 71, 130, 219, 154, 170, 243, 182, 255, 255, 128}
},
{
{ 1, 182, 225, 249, 219, 240, 255, 224, 128, 128, 128},
{ 149, 150, 226, 252, 216, 205, 255, 171, 128, 128, 128},
{ 28, 108, 170, 242, 183, 194, 254, 223, 255, 255, 128}
},
{
{ 1, 81, 230, 252, 204, 203, 255, 192, 128, 128, 128},
{ 123, 102, 209, 247, 188, 196, 255, 233, 128, 128, 128},
{ 20, 95, 153, 243, 164, 173, 255, 203, 128, 128, 128}
},
{
{ 1, 222, 248, 255, 216, 213, 128, 128, 128, 128, 128},
{ 168, 175, 246, 252, 235, 205, 255, 255, 128, 128, 128},
{ 47, 116, 215, 255, 211, 212, 255, 255, 128, 128, 128}
},
{
{ 1, 121, 236, 253, 212, 214, 255, 255, 128, 128, 128},
{ 141, 84, 213, 252, 201, 202, 255, 219, 128, 128, 128},
{ 42, 80, 160, 240, 162, 185, 255, 205, 128, 128, 128}
},
{
{ 1, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 244, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 238, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128}
}
}
};
---- End code block ----------------------------------------
After decoding the DCTs/WHTs as described above, each (quantized) coefficient in each subblock is multiplied by one of six dequantization factors, the choice of factor depending on the plane (Y2, Y, or chroma) and position (DC = coefficient zero, AC = any
上記のDCTS/WHTをデコードした後、各サブブロックの各（量子化された）係数に6つの非定量化係数のいずれかを掛けます。平面（Y2、Y、またはChroma）と位置（DC =係数ゼロに依存する因子の選択、ac = any
other coefficient). If the current macroblock has overridden the quantizer level (as described in Section 10), then the six factors are looked up from two dequantization tables with appropriate scaling and clamping using the single index supplied by the override. Otherwise, the frame-level dequantization factors (as described in Section 9.6) are used. In either case, the multiplies are computed and stored using 16-bit signed integers.
その他の係数）。現在のマクロブロックが量子化器レベルをオーバーライドしている場合（セクション10で説明されているように）、6つの要因は、オーバーライドによって提供された単一のインデックスを使用して、適切なスケーリングとクランプを使用して、2つのデコンティングテーブルから調べられます。それ以外の場合、フレームレベルの定量化係数（セクション9.6で説明されている）が使用されます。どちらの場合でも、マルチプリは計算され、16ビットの署名された整数を使用して保存されます。
The two dequantization tables, which may also be found in the reference decoder file dequant_data.h (Section 20.3), are as follows.
参照デコーダーファイルdequant_data.h（セクション20.3）にも見られる2つのデコンティゼーションテーブルは、次のとおりです。
---- Begin code block --------------------------------------
static const int dc_qlookup[QINDEX_RANGE] = { 4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17, 18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 91, 93, 95, 96, 98, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 143, 145, 148, 151, 154, 157, };
static const int dc_qlookup [qindex_range] = {4、5、6、7、8、9、10、11、12、13、14、15、16、17、18、19、20、20、21、21、22、22、23、23、24、25、25、26、27、28、29、30、31、32、33、34、35、36、37、37、38、39、40、41、42、43、44、45、46、46、47、48、49、50、51、52、53、54、55、56、57、58、59、60、61、62、63、64、64、65、66、67、68、69、70、71、72、73、74、75、76、76、77、78、79、80、81、82、83、84、85、86、87、87、88、89、91、93、95、96、98、100、101、102、104、106、108、110、112、114、116、118、122、124、126、128、130、132、134、136、138、140、143、145、148、151、154、157、};
static const int ac_qlookup[QINDEX_RANGE] = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 119, 122, 125, 128, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 161, 164, 167, 170, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 234, 239, 245, 249, 254, 259, 264, 269, 274, 279, 284, };
static const int ac_qlookup [qindex_range] = {4、5、6、7、8、9、10、11、12、13、14、15、16、17、18、19、20、21、22、23、24、25、26、27、28、29、30、31、32、33、34、35、36、37、38、39、40、41、42、43、44、45、46、47、48、49、50、51、52、53、54、55、56、57、58、60、62、64、66、68、70、72、74、76、78、80、82、84、86、88、90、92、94、96、98、100、102、104、106、108、110、112、114、116、119、122、125、128、131、134、137、140、143、146、149、152、149、152、155、158、161、164、167、170、173、177、181、185、189、193、197、201、205、209、213、217、221、225、229、234、239、245、249、249、249、249、254、259、264、269、274、279、284、};
---- End code block ----------------------------------------
Lookup values from the above two tables are directly used in the DC and AC coefficients in Y1, respectively. For Y2 and chroma, values from the above tables undergo either scaling or clamping before the multiplies. Details regarding these scaling and clamping processes can be found in related lookup functions in dixie.c (Section 20.4).
上記の2つのテーブルのルックアップ値は、それぞれY1のDCおよびAC係数で直接使用されます。Y2とChromaの場合、上記のテーブルの値は、マルチプレゼントの前にスケーリングまたはクランプのいずれかを受けます。これらのスケーリングおよびクランププロセスに関する詳細は、dixie.c（セクション20.4）の関連するルックアップ関数に記載されています。
If the Y2 residue block exists (i.e., the macroblock luma mode is not SPLITMV or B_PRED), it is inverted first (using the inverse WHT) and the element of the result at row i, column j is used as the 0th coefficient of the Y subblock at position (i, j), that is, the Y subblock whose index is (i * 4) + j. As discussed in Section 13, if the luma mode is B_PRED or SPLITMV, the 0th Y coefficients are part of the residue signal for the subblocks themselves.
Y2残基ブロックが存在する場合（つまり、マクロブロックLUMAモードがsplitMVまたはB_PREDではない場合）、最初に反転し（逆WHTを使用）、行Iで結果の要素が列jが使用されます。y位置（i、j）のyサブブロック、つまり、インデックスが（i * 4）jのyサブブロック。セクション13で説明したように、LUMAモードがB_PREDまたはSplitMVの場合、0番目のY係数はサブブロック自体の残基信号の一部です。
In either case, the inverse transforms for the sixteen Y subblocks and eight chroma subblocks are computed next. All 24 of these inversions are independent of each other; their results may (at least conceptually) be stored in 24 separate 4x4 arrays.
どちらの場合でも、16 Yのサブブロックと8つのクロマサブブロックの逆変換が次に計算されます。これらの反転の24はすべて互いに独立しています。それらの結果は（少なくとも概念的に）24個の別々の4x4アレイに保存される場合があります。
As is done by the reference decoder, an implementation may wish to represent the prediction and residue buffers as macroblock-sized arrays (that is, a 16x16 Y buffer and two 8x8 chroma buffers). Regarding the inverse DCT implementation given below, this requires a simple adjustment to the address calculation for the resulting residue pixels.
参照デコーダーによって行われるように、実装は、予測と残基バッファーをマクロブロックサイズのアレイ（つまり16x16 Yバッファーと2つの8x8クロマバッファー）として表すことを望む場合があります。以下に示す逆DCTの実装に関して、これには、結果の残基ピクセルのアドレス計算を簡単に調整する必要があります。
As previously discussed (see Sections 2 and 13), for macroblocks encoded using prediction modes other than B_PRED and SPLITMV, the DC values derived from the DCT transform on the 16 Y blocks are collected to construct a 25th block of a macroblock (16 Y, 4 U, 4 V constitute the 24 blocks). This 25th block is transformed using a Walsh-Hadamard transform (WHT).
以前に説明したように（セクション2および13を参照）、B_PREDおよびSplitMV以外の予測モードを使用してエンコードされたマクロブロックについては、16 YブロックのDCT変換から派生したDC値が収集され、マクロブロックの25番目のブロックを構築します（16 Y、4 u、4 vは24ブロックを構成します）。この25番目のブロックは、Walsh-Hadamard Transform（WHT）を使用して変換されます。
The inputs to the inverse WHT (that is, the dequantized coefficients), the intermediate "horizontally detransformed" signal, and the completely detransformed residue signal are all stored as arrays of 16-bit signed integers.
逆WHT（つまり、不安定化係数）への入力、中間の「水平に変形した」信号、および完全に変形した残基信号はすべて、16ビットの署名整数のアレイとして保存されます。
Following the tradition of specifying bitstream format using the decoding process, we specify the inverse WHT in the decoding process using the following C-style source code:
デコードプロセスを使用してBitStream形式を指定する伝統に従って、次のCスタイルのソースコードを使用して、デコードプロセスの逆WHTを指定します。
---- Begin code block --------------------------------------
void vp8_short_inv_walsh4x4_c(short *input, short *output)
{
int i;
int a1, b1, c1, d1;
int a2, b2, c2, d2;
short *ip = input;
short *op = output;
int temp1, temp2;
for(i=0;i<4;i++)
{
a1 = ip[0] + ip[12];
b1 = ip[4] + ip[8];
c1 = ip[4] - ip[8];
d1 = ip[0] - ip[12];
op[0] = a1 + b1;
op[4] = c1 + d1;
op[8] = a1 - b1;
op[12]= d1 - c1;
ip++;
op++;
}
ip = output;
op = output;
for(i=0;i<4;i++)
{
a1 = ip[0] + ip[3];
b1 = ip[1] + ip[2];
c1 = ip[1] - ip[2];
d1 = ip[0] - ip[3];
a2 = a1 + b1;
b2 = c1 + d1;
c2 = a1 - b1;
d2 = d1 - c1;
op[0] = (a2+3)>>3;
op[1] = (b2+3)>>3;
op[2] = (c2+3)>>3;
op[3] = (d2+3)>>3;
ip+=4;
op+=4;
}
}
---- End code block ----------------------------------------
In the case that there is only one non-zero DC value in input, the inverse transform can be simplified to the following:
入力にゼロ以外のDC値が1つしかない場合、逆変換は次のように簡素化できます。
---- Begin code block --------------------------------------
void vp8_short_inv_walsh4x4_1_c(short *input, short *output)
{
int i;
int a1;
short *op=output;
a1 = ((input[0] + 3)>>3);
for(i=0;i<4;i++)
{
op[0] = a1;
op[1] = a1;
op[2] = a1;
op[3] = a1;
op+=4;
}
}
---- End code block ----------------------------------------
It should be noted that a conforming decoder should implement the inverse transform using exactly the same rounding to achieve bit-wise matching output to the output of the process specified by the above C source code.
適合デコーダーは、上記のCソースコードで指定されたプロセスの出力に少し一致する出力を実現するために、まったく同じ丸めを使用して逆変換を実装する必要があることに注意してください。
The reference decoder WHT inversion may be found in the file idct_add.c (Section 20.8).
参照デコーダーWHT反転は、ファイルIDCT_ADD.C（セクション20.8）に記載されている場合があります。
All of the DCT inversions are computed in exactly the same way. In principle, VP8 uses a classical 2-D inverse discrete cosine transform, implemented as two passes of 1-D inverse DCT. The 1-D inverse DCT was calculated using a similar algorithm to what was described in [Loeffler]. However, the paper only provided the 8-point and 16-point version of the algorithms, which was adapted by On2 to perform the 4-point 1-D DCT.
すべてのDCT反転は、まったく同じ方法で計算されます。原則として、VP8は、1次元DCTの2つのパスとして実装された古典的な2-D逆離散コサイン変換を使用します。1-D逆DCTは、[Loeffler]で説明されているものと同様のアルゴリズムを使用して計算されました。ただし、このペーパーは、4ポイント1-D DCTを実行するためにON2によって適合された8ポイントと16ポイントのアルゴリズムのみを提供しました。
Accurate calculation of 1-D DCT of the above algorithm requires infinite precision. VP8 of course can use only a finite-precision approximation. Also, the inverse DCT used by VP8 takes care of normalization of the standard unitary transform; that is, every dequantized coefficient has roughly double the size of the corresponding unitary coefficient. However, at all but the highest datarates, the discrepancy between transmitted and ideal coefficients is due almost entirely to (lossy) compression and not to errors induced by finite-precision arithmetic.
上記のアルゴリズムの1-D DCTの正確な計算には、無限の精度が必要です。もちろん、VP8は有限前の近似のみを使用できます。また、VP8が使用する逆DCTは、標準的な単一変換の正規化を処理します。つまり、すべての不安定な係数は、対応する単一係数のサイズの約2倍です。ただし、最高のデータレートを除いて、送信係数と理想係数との矛盾は、ほぼ完全に（損失のある）圧縮によるものであり、有限精度算術によって誘発されるエラーではありません。
The inputs to the inverse DCT (that is, the dequantized coefficients), the intermediate "horizontally detransformed" signal, and the completely detransformed residue signal are all stored as arrays of 16-bit signed integers. The details of the computation are as follows.
逆DCT（つまり、不安定化係数）への入力、中間の「水平に変形した」信号、および完全に変形した残基信号はすべて、16ビットの署名整数のアレイとして保存されます。計算の詳細は次のとおりです。
It should also be noted that this implementation makes use of the 16-bit fixed-point version of two multiplication constants:
また、この実装では、2つの乗算定数の16ビット固定点バージョンを使用していることにも注意してください。
sqrt(2) * cos (pi/8)
sqrt（2） * cos（pi/8）
sqrt(2) * sin (pi/8)
sqrt（2） * sin（pi/8）
Because the first constant is bigger than 1, to maintain the same 16-bit fixed-point precision as the second one, we make use of the fact that
最初の定数は1より大きいため、2番目の定数と同じ16ビット固定点精度を維持するため、私たちはという事実を利用します。
x * a = x + x*(a-1)
therefore
したがって
x * sqrt(2) * cos (pi/8) = x + x * (sqrt(2) * cos(pi/8)-1)
---- Begin code block --------------------------------------
/* IDCT implementation */
static const int cospi8sqrt2minus1=20091;
static const int sinpi8sqrt2 =35468;
void short_idct4x4llm_c(short *input, short *output, int pitch)
{
int i;
int a1, b1, c1, d1;
short *ip=input;
short *op=output;
int temp1, temp2;
int shortpitch = pitch>>1;
for(i=0;i<4;i++)
{
a1 = ip[0]+ip[8];
b1 = ip[0]-ip[8];
temp1 = (ip[4] * sinpi8sqrt2)>>16;
temp2 = ip[12]+((ip[12] * cospi8sqrt2minus1)>>16);
c1 = temp1 - temp2;
temp1 = ip[4] + ((ip[4] * cospi8sqrt2minus1)>>16);
temp2 = (ip[12] * sinpi8sqrt2)>>16;
d1 = temp1 + temp2;
op[shortpitch*0] = a1+d1;
op[shortpitch*3] = a1-d1;
op[shortpitch*1] = b1+c1;
op[shortpitch*2] = b1-c1;
ip++;
op++;
}
ip = output;
op = output;
for(i=0;i<4;i++)
{
a1 = ip[0]+ip[2];
b1 = ip[0]-ip[2];
temp1 = (ip[1] * sinpi8sqrt2)>>16;
temp2 = ip[3]+((ip[3] * cospi8sqrt2minus1)>>16);
c1 = temp1 - temp2;
temp1 = ip[1] + ((ip[1] * cospi8sqrt2minus1)>>16);
temp2 = (ip[3] * sinpi8sqrt2)>>16;
d1 = temp1 + temp2;
op[0] = (a1+d1+4)>>3;
op[3] = (a1-d1+4)>>3;
op[1] = (b1+c1+4)>>3;
op[2] = (b1-c1+4)>>3;
ip+=shortpitch;
op+=shortpitch;
}
}
---- End code block ----------------------------------------
The reference decoder DCT inversion may be found in the file idct_add.c (Section 20.8).
参照デコーダーDCTの反転は、ファイルIDCT_ADD.C（セクション20.8）に記載されている場合があります。
Finally, the prediction and residue signals are summed to form the reconstructed macroblock, which, except for loop filtering (taken up next), completes the decoding process.
最後に、予測と残基シグナルは合計されて再構築されたマクロブロックを形成します。これは、ループフィルタリング（次に撮影）を除き、デコードプロセスを完了します。
The summing procedure is fairly straightforward, having only a couple of details. The prediction and residue buffers are both arrays of 16-bit signed integers. Each individual (Y, U, and V pixel) result is calculated first as a 32-bit sum of the prediction and residue, and is then saturated to 8-bit unsigned range (using, say, the clamp255 function defined above) before being stored as an 8-bit unsigned pixel value.
合計手順はかなり簡単で、詳細は2つしかありません。予測バッファと残基バッファーは、どちらも16ビットの署名された整数の配列です。各個々の個々（y、u、およびvピクセル）の結果は、最初に予測と残基の32ビット合計として計算され、次に8ビットの符号なし範囲に飽和します（たとえば、上記で定義されたclamp255関数を使用）8ビットの符号なしピクセル値として保存されます。
VP8 also supports a mode where the encoding of a bitstream guarantees all reconstructed pixel values between 0 and 255; compliant bitstreams of such requirements have the clamp_type bit in the frame header set to 1. In such a case, the clamp255 function is no longer required.
VP8は、ビットストリームのエンコードが0〜255の間にすべての再構築されたピクセル値を保証するモードもサポートしています。このような要件の準拠のビットストリームには、フレームヘッダーが1に設定されたCLAMP_TYPEビットがあります。そのような場合、CLAMP255関数は不要になります。
The summation process is the same, regardless of the (intra or inter) mode of prediction in effect for the macroblock. The reference decoder implementation of reconstruction may be found in the file idct_add.c.
マクロブロックの（イントラまたはインター）予測モードに関係なく、合計プロセスは同じです。再構成の参照デコーダー実装は、ファイルIDCT_ADD.Cに記載されている場合があります。
Loop filtering is the last stage of frame reconstruction and the next-to-last stage of the decoding process. The loop filter is applied to the entire frame after the summation of predictor and residue signals, as described in Section 14.
ループフィルタリングは、フレーム再構築の最後の段階であり、デコードプロセスの次の段階です。セクション14で説明されているように、ループフィルターは、予測因子と残基シグナルの合計後にフレーム全体に適用されます。
The purpose of the loop filter is to eliminate (or at least reduce) visually objectionable artifacts associated with the semi-independence of the coding of macroblocks and their constituent subblocks.
ループフィルターの目的は、マクロブロックとその構成要素のサブブロックのコーディングの半独立に関連する視覚的に好ましくないアーティファクトを排除（または少なくとも削減する）ことです。
As was discussed in Section 5, the loop filter is "integral" to decoding, in that the results of loop filtering are used in the prediction of subsequent frames. Consequently, a functional decoder implementation must perform loop filtering exactly as described here. This is distinct from any postprocessing that may be applied only to the image immediately before display; such postprocessing is entirely at the option of the implementor (and/or user) and has no effect on decoding per se.
セクション5で説明したように、ループフィルターはデコードに「積分」しています。これは、ループフィルタリングの結果が後続のフレームの予測で使用されているからです。したがって、機能的なデコーダーの実装は、ここで説明するように正確にループフィルタリングを実行する必要があります。これは、ディスプレイの直前に画像にのみ適用される可能性のあるポストプロセスとは異なります。このような後処理は、実装者（および/またはユーザー）のオプションに完全に存在し、それ自体のデコードに影響を与えません。
The baseline frame-level parameters controlling the loop filter are defined in the frame header (Section 9.4) along with a mechanism for adjustment based on a macroblock's prediction mode and/or reference frame. The first is a flag (filter_type) selecting the type of filter (normal or simple); the other two are numbers (loop_filter_level and sharpness_level) that adjust the strength or sensitivity of the filter. As described in Sections 9.3 and 10, loop_filter_level may also be overridden on a per-macroblock basis using segmentation.
ループフィルターを制御するベースラインフレームレベルのパラメーターは、マクロブロックの予測モードおよび/または参照フレームに基づく調整のメカニズムとともに、フレームヘッダー（セクション9.4）で定義されています。1つ目は、フィルターのタイプを選択するフラグ（filter_type）です（通常または単純）。他の2つは、フィルターの強度または感度を調整する数字（loop_filter_levelとsharpness_level）です。セクション9.3および10で説明されているように、loop_filter_levelは、セグメンテーションを使用してマクロブロックごとにオーバーライドされる場合があります。
Loop filtering is one of the more computationally intensive aspects of VP8 decoding. This is the reason for the existence of the optional, less-demanding simple filter type.
ループフィルタリングは、VP8デコードのより計算的に集中的な側面の1つです。これが、オプションの、それほど強くない単純なフィルタータイプが存在する理由です。
Note carefully that loop filtering must be skipped entirely if loop_filter_level at either the frame header level or macroblock override level is 0. In no case should the loop filter be run with a value of 0; it should instead be skipped.
フレームヘッダーレベルまたはマクロブロックオーバーライドレベルのいずれかでloop_filter_levelが0である場合、ループフィルタリングを完全にスキップする必要があることに注意してください。代わりにスキップする必要があります。
We begin by discussing the aspects of loop filtering that are independent of the controlling parameters and type of filter chosen.
まず、制御パラメーターと選択したフィルターの種類に依存しないループフィルタリングの側面について説明することから始めます。
The Y, U, and V planes are processed independently and identically.
y、u、およびV平面は、独立して同一に処理されます。
The loop filter acts on the edges between adjacent macroblocks and on the edges between adjacent subblocks of a macroblock. All such edges are horizontal or vertical. For each pixel position on an edge, a small number (two or three) of pixels adjacent to either side of the position are examined and possibly modified. The displacements of these pixels are at a right angle to the edge orientation; that is, for a horizontal edge, we treat the pixels immediately above and below the edge position, and for a vertical edge, we treat the pixels immediately to the left and right of the edge.
ループフィルターは、隣接するマクロブロック間のエッジと、マクロブロックの隣接するサブブロック間のエッジに作用します。そのようなエッジはすべて水平または垂直です。エッジ上の各ピクセル位置について、位置の両側に隣接するピクセルの少数（2つまたは3つ）が調べられ、おそらく変更されます。これらのピクセルの変位は、エッジの向きに対して直角です。つまり、水平方向のエッジの場合、エッジの位置のすぐ上と下のピクセルを扱い、垂直方向のエッジでは、ピクセルをすぐにエッジの左右に扱います。
We call this collection of pixels associated to an edge position a segment; the length of a segment is 2, 4, 6, or 8. Excepting that the normal filter uses slightly different algorithms for, and either filter may apply different control parameters to, the edges between macroblocks and those between subblocks, the treatment of edges is quite uniform: All segments straddling an edge are treated identically; there is no distinction between the treatment of horizontal and vertical edges, whether between macroblocks or between subblocks.
エッジ位置に関連付けられたピクセルのこのコレクションをセグメントと呼びます。セグメントの長さは2、4、6、または8です。通常のフィルターがわずかに異なるアルゴリズムを使用することを除いて、マクロブロックとサブブロックの間のエッジのエッジには、エッジの処理が異なる制御パラメーターを適用する場合があります。非常に均一：エッジにまたがるすべてのセグメントは同じように扱われます。マクロブロック間またはサブブロック間であろうと、水平エッジと垂直エッジの処理には区別はありません。
As a consequence, adjacent subblock edges within a macroblock may be concatenated and processed in their entirety. There is a single 8-pixel-long vertical edge horizontally centered in each of the U and V blocks (the concatenation of upper and lower 4-pixel edges between chroma subblocks), and three 16-pixel-long vertical edges at horizontal positions 1/4, 1/2, and 3/4 the width of the luma macroblock, each representing the concatenation of four 4-pixel sub-edges between pairs of Y subblocks.
結果として、マクロブロック内の隣接するサブブロックエッジを連結して処理することができます。各UおよびVブロック（クロマサブブロック間の上限と下部4ピクセルのエッジの連結）と、水平位置1に3つの16ピクセル長垂直エッジ1にある1つの8ピクセル長垂直エッジが水平に中心にあります1/4、1/2、および3/4 Lumaマクロブロックの幅は、それぞれがyサブブロックのペア間の4つの4ピクセルサブエッジの連結を表しています。
The macroblocks comprising the frame are processed in the usual raster-scan order. Each macroblock is "responsible for" the inter-macroblock edges immediately above and to the left of it (but not the edges below and to the right of it), as well as the edges between its subblocks.
フレームを含むマクロブロックは、通常のラスタースキャン順序で処理されます。各マクロブロックは、そのサブブロック間のエッジだけでなく、そのすぐ上と左側と左側と左側（ただし右側と右側ではなく）の間、マクロブロック間のエッジを「責任」します。
For each macroblock M, there are four filtering steps, which are, (almost) in order:
各マクロブロックMには、4つのフィルタリングステップがあります。これは（ほぼ）順番です。
1. If M is not on the leftmost column of macroblocks, filter across the left (vertical) inter-macroblock edge of M.
1. mがマクロブロックの左端の列にない場合は、Mの左（垂直）間マクロブロックエッジを除去します。
2. Filter across the vertical subblock edges within M.
2. M内の垂直サブブロックエッジを横切ってフィルタリングします
3. If M is not on the topmost row of macroblocks, filter across the top (horizontal) inter-macroblock edge of M.
3. Mがマクロブロックの最上列にない場合は、Mの上部（水平）間マクロブロックエッジを除去します。
4. Filter across the horizontal subblock edges within M.
4. M内の水平サブブロックエッジを横切ってフィルタリングします
We write MY, MU, and MV for the planar constituents of M, that is, the 16x16 luma block, 8x8 U block, and 8x8 V block comprising M.
Mの平面成分、つまり16x16 Lumaブロック、8x8 Uブロック、およびMで構成される8x8 Vブロックのために、私、MU、およびMVを書きます。
In step 1, for each of the three blocks MY, MU, and MV, we filter each of the (16 luma or 8 chroma) segments straddling the column separating the block from the block immediately to the left of it, using the inter-macroblock filter and controls associated to the loop_filter_level and sharpness_level.
ステップ1では、3つのブロックのそれぞれについて、MY、MU、およびMVで、ブロックをすぐに左に分離する列を囲む列にまたがる各（16ルーマまたは8クロマ）セグメントのそれぞれをフィルタリングします。loop_filter_levelとsharpness_levelに関連付けられたマクロブロックフィルターとコントロール。
In step 4, we filter across the (three luma and one each for U and V) vertical subblock edges described above, this time using the inter-subblock filter and controls.
ステップ4では、上記の垂直サブブロックエッジ（3つのLUMAと1つのLUMAと1つ）を上にフィルタリングします。今回は、サブブロック間フィルターとコントロールを使用します。
Steps 2 and 4 are skipped for macroblocks that satisfy both of the following two conditions:
ステップ2と4は、次の2つの条件の両方を満たすマクロブロックのためにスキップされています。
1. Macroblock coding mode is neither B_PRED nor SPLITMV; and
1. マクロブロックコーディングモードは、b_predでもsplitmvでもありません。と
2. There is no DCT coefficient coded for the whole macroblock.
2. マクロブロック全体にコード化されたDCT係数はありません。
For these macroblocks, loop filtering for edges between subblocks internal to a macroblock is effectively skipped. This skip strategy significantly reduces VP8 loop-filtering complexity.
これらのマクロブロックの場合、マクロブロックの内部のサブブロック間のエッジのループフィルタリングが効果的にスキップされます。このスキップ戦略により、VP8ループフィルタリングの複雑さが大幅に削減されます。
Edges between macroblocks and those between subblocks are treated with different control parameters (and, in the case of the normal filter, with different algorithms). Except for pixel addressing, there is no distinction between the treatment of vertical and horizontal edges. Luma edges are always 16 pixels long, chroma edges are always 8 pixels long, and the segments straddling an edge are treated identically; this of course facilitates vector processing.
マクロブロックとサブブロック間のエッジは、異なる制御パラメーターで処理されます（そして、通常のフィルターの場合、異なるアルゴリズムで）。ピクセルのアドレス指定を除き、垂直と水平のエッジの処理には区別はありません。Lumaのエッジは常に16ピクセルの長さで、クロマのエッジは常に8ピクセルの長さであり、エッジにまたがるセグメントは同じように扱われます。もちろん、これはベクトル処理を容易にします。
Because many pixels belong to segments straddling two or more edges, and so will be filtered more than once, the order in which edges are processed given above must be respected by any implementation. Within a single edge, however, the segments straddling that edge are disjoint, and the order in which these segments are processed is immaterial.
多くのピクセルが2つ以上のエッジにまたがるセグメントに属しているため、複数回フィルタリングされるため、上記のエッジが処理される順序は、実装によって尊重されなければなりません。ただし、単一のエッジ内では、そのエッジが際立っているセグメントはばらばらであり、これらのセグメントが処理される順序は重要ではありません。
Before taking up the filtering algorithms themselves, we should emphasize a point already made: Even though the pixel segments associated to a macroblock are antecedent to the macroblock (that is, lie within the macroblock or in already-constructed macroblocks), a
フィルタリングアルゴリズム自体を取り上げる前に、すでに作成されたポイントを強調する必要があります。マクロブロックに関連付けられたピクセルセグメントがマクロブロック（つまり、マクロブロック内またはすでに構成されているマクロブロック内にあります）に先行していますが、
macroblock must not be filtered immediately after its "reconstruction" (described in Section 14). Rather, the loop filter applies after all the macroblocks have been "reconstructed" (i.e., had their predictor summed with their residue); correct decoding is predicated on the fact that already-constructed portions of the current frame referenced via intra-prediction (described in Section 12) are not yet filtered.
マクロブロックは、その「再構築」の直後にフィルタリングしてはなりません（セクション14で説明）。むしろ、ループフィルターは、すべてのマクロブロックが「再構築」された後に適用されます（つまり、予測因子が残留物で合計されていました）。正しいデコードは、予測内（セクション12で説明）を介して参照されている現在のフレームのすでに構成されている部分がまだフィルタリングされていないという事実に基づいています。
Having described the overall procedure of, and pixels affected by, the loop filter, we turn our attention to the treatment of individual segments straddling edges. We begin by describing the simple filter, which, as the reader might guess, is somewhat simpler than the normal filter.
ループフィルターの全体的な手順とピクセルを説明した後、エッジにまたがる個々のセグメントの処理に注意を向けます。まず、読者が推測するように、通常のフィルターよりもやや単純な単純なフィルターを説明することから始めます。
Note that the simple filter only applies to luma edges. Chroma edges are left unfiltered.
単純なフィルターは、Lumaエッジにのみ適用されることに注意してください。クロマのエッジはフィルタリングされていません。
Roughly speaking, the idea of loop filtering is, within limits, to reduce the difference between pixels straddling an edge. Differences in excess of a threshold (associated to the loop_filter_level) are assumed to be "natural" and are unmodified; differences below the threshold are assumed to be artifacts of quantization and the (partially) separate coding of blocks, and are reduced via the procedures described below. While the loop_filter_level is in principle arbitrary, the levels chosen by a VP8 compressor tend to be correlated to quantizer levels.
大まかに言えば、ループフィルタリングのアイデアは、制限内で、エッジにまたがるピクセルの違いを減らすことです。しきい値の過剰（loop_filter_levelに関連付けられている）の違いは、「自然」であると想定されており、変更されていません。しきい値以下の違いは、量子化のアーティファクトであり、（部分的に）ブロックの個別のコーディングであると想定されており、以下の手順を介して減少します。loop_filter_levelは原則としてarbitrary意的ですが、VP8コンプレッサーによって選択されたレベルは、量子化レベルと相関する傾向があります。
Most of the filtering arithmetic is done using 8-bit signed operands (having a range of -128 to +127, inclusive), supplemented by 16-bit temporaries holding results of multiplies.
フィルタリング算術のほとんどは、8ビットの署名されたオペランド（範囲の-128〜127、包括的）を使用して行われます。
Sums and other temporaries need to be "clamped" to a valid signed 8-bit range:
合計およびその他の一時的なものは、有効な署名された8ビット範囲に「クランプ」する必要があります。
---- Begin code block --------------------------------------
int8 c(int v)
{
return (int8) (v < -128 ? -128 : (v < 128 ? v : 127));
}
---- End code block ----------------------------------------
Since pixel values themselves are unsigned 8-bit numbers, we need to convert between signed and unsigned values:
ピクセル値自体は署名されていない8ビット番号であるため、署名された値と符号なしの値を変換する必要があります。
---- Begin code block --------------------------------------
/* Convert pixel value (0 <= v <= 255) to an 8-bit signed
number. */
int8 u2s(Pixel v) { return (int8) (v - 128);}
/* Clamp, then convert signed number back to pixel value. */
Pixel s2u(int v) { return (Pixel) (c(v) + 128);}
---- End code block ----------------------------------------
Filtering is often predicated on absolute-value thresholds. The following function is the equivalent of the standard library function abs, whose prototype is found in the standard header file stdlib.h. For us, the argument v is always the difference between two pixels and lies in the range -255 <= v <= +255.
フィルタリングは、多くの場合、絶対値のしきい値に基づいています。次の関数は、標準のライブラリ関数ABSに相当し、そのプロトタイプは標準ヘッダーファイルstdlib.hにあります。私たちにとって、引数Vは常に2つのピクセルの違いであり、範囲-255 <= v <= 255の範囲です。
---- Begin code block --------------------------------------
int abs(int v) { return v < 0? -v : v;}
---- End code block ----------------------------------------
An actual implementation would of course use inline functions or macros to accomplish these trivial procedures (which are used by both the normal and simple loop filters). An optimal implementation would probably express them in machine language, perhaps using single instruction, multiple data (SIMD) vector instructions. On many SIMD processors, the saturation accomplished by the above clamping function is often folded into the arithmetic instructions themselves, obviating the explicit step taken here.
実際の実装では、もちろんインライン関数またはマクロを使用して、これらの些細な手順（通常のループフィルターと単純なループフィルターの両方で使用されます）を達成します。最適な実装は、おそらく単一命令、複数のデータ（SIMD）ベクトル命令を使用して、おそらく機械言語でそれらを表現するでしょう。多くのSIMDプロセッサでは、上記のクランプ関数によって達成される飽和は、しばしば算術命令自体に折りたたまれ、ここで取られた明示的なステップを取り除きます。
To simplify the specification of relative pixel positions, we use the word "before" to mean "immediately above" (for a vertical segment straddling a horizontal edge) or "immediately to the left of" (for a horizontal segment straddling a vertical edge), and the word "after" to mean "immediately below" or "immediately to the right of".
相対ピクセルの位置の仕様を簡素化するために、「前」を意味する「前」を意味する（垂直セグメントの場合）または「左の左側にある」（垂直エッジにまたがる水平セグメントの場合）を意味するように「」という単語を使用します。、および「後の」という言葉は、「すぐ下」または「右側の右側」を意味します。
Given an edge, a segment, and a limit value, the simple loop filter computes a value based on the four pixels that straddle the edge (two either side). If that value is below a supplied limit, then, very roughly speaking, the two pixel values are brought closer to each other, "shaving off" something like a quarter of the difference. The
エッジ、セグメント、および制限値が与えられた場合、シンプルループフィルターは、エッジにまたがる4つのピクセル（2つの側面）に基づいて値を計算します。その値が供給された制限を下回っている場合、非常に大まかに言えば、2つのピクセル値は互いに近づき、違いの4分の1のようなものを「シェービング」します。
same procedure is used for all segments straddling any type of edge, regardless of the nature (inter-macroblock, inter-subblock, luma, or chroma) of the edge; only the limit value depends on the edge type.
エッジの性質（マクロブロック間、サブブロック間、ルーマ、またはクロマ）に関係なく、あらゆるタイプのエッジにまたがるすべてのセグメントに同じ手順が使用されます。制限値のみがエッジタイプによって異なります。
The exact procedure (for a single segment) is as follows; the subroutine common_adjust is used by both the simple filter presented here and the normal filters discussed in Section 15.3.
正確な手順（単一セグメントの場合）は次のとおりです。Subroutine common_adjustは、ここに示されている単純なフィルターとセクション15.3で説明した通常のフィルターの両方で使用されます。
---- Begin code block --------------------------------------
int8 common_adjust(
int use_outer_taps, /* filter is 2 or 4 taps wide */
const Pixel *P1, /* pixel before P0 */
Pixel *P0, /* pixel before edge */
Pixel *Q0, /* pixel after edge */
const Pixel *Q1 /* pixel after Q0 */
) {
cint8 p1 = u2s(*P1); /* retrieve and convert all 4 pixels */
cint8 p0 = u2s(*P0);
cint8 q0 = u2s(*Q0);
cint8 q1 = u2s(*Q1);
/* Disregarding clamping, when "use_outer_taps" is false,
"a" is 3*(q0-p0). Since we are about to divide "a" by
8, in this case we end up multiplying the edge
difference by 5/8.
When "use_outer_taps" is true (as for the simple filter),
"a" is p1 - 3*p0 + 3*q0 - q1, which can be thought of as
a refinement of 2*(q0 - p0), and the adjustment is
something like (q0 - p0)/4. */
int8 a = c((use_outer_taps? c(p1 - q1) : 0) + 3*(q0 - p0));
/* b is used to balance the rounding of a/8 in the case where
the "fractional" part "f" of a/8 is exactly 1/2. */
cint8 b = (c(a + 3)) >> 3;
/* Divide a by 8, rounding up when f >= 1/2.
Although not strictly part of the C language,
the right shift is assumed to propagate the sign bit. */
a = c(a + 4) >> 3;
/* Subtract "a" from q0, "bringing it closer" to p0. */
*Q0 = s2u(q0 - a);
/* Add "a" (with adjustment "b") to p0, "bringing it closer"
to q0.
The clamp of "a+b", while present in the reference decoder,
is superfluous; we have -16 <= a <= 15 at this point. */
*P0 = s2u(p0 + b);
return a; }
aを返します。}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
void simple_segment(
uint8 edge_limit, /* do nothing if edge difference
exceeds limit */
const Pixel *P1, /* pixel before P0 */
Pixel *P0, /* pixel before edge */
Pixel *Q0, /* pixel after edge */
const Pixel *Q1 /* pixel after Q0 */
) {
if ((abs(*P0 - *Q0)*2 + abs(*P1 - *Q1)/2) <= edge_limit))
common_adjust(1, P1, P0, Q0, Q1); /* use outer taps */
}
---- End code block ----------------------------------------
We make a couple of remarks about the rounding procedure above. When b is zero (that is, when the "fractional part" of a is not 1/2), we are (except for clamping) adding the same number to p0 as we are subtracting from q0. This preserves the average value of p0 and q0, but the resulting difference between p0 and q0 is always even; in particular, the smallest non-zero gradation +-1 is not possible here.
上記の丸め手順についていくつかの発言をします。Bの場合（つまり、Aの「分数部分」が1/2ではない場合）、Q0から減算しているのと同じ数をP0に追加しています（クランプを除く）。これにより、P0とQ0の平均値が保持されますが、P0とQ0の結果の違いは常に均一です。特に、ここでは最小の非ゼログラデーション-1は不可能です。
When b is one, the value we add to p0 (again except for clamping) is one less than the value we are subtracting from q0. In this case, the resulting difference is always odd (and the small gradation +-1 is possible), but the average value is reduced by 1/2, yielding, for instance, a very slight darkening in the luma plane. (In the very unlikely event of appreciable darkening after a large number of interframes, a compressor would of course eventually compensate for this in the selection of predictor and/or residue.)
Bが1の場合、P0に追加する値（再びクランプを除く）は、Q0から差し引く値よりも1つ低くなります。この場合、結果の違いは常に奇妙です（そして小さなグラデーション-1は可能です）が、平均値は1/2に減少し、例えばLuma平面では非常にわずかに暗くなります。（多数のインターフレームの後に非常にありそうもない暗くなるイベントでは、コンプレッサーはもちろん、最終的には予測因子および/または残基の選択でこれを補償します。）
The derivation of the edge_limit value used above, which depends on the loop_filter_level and sharpness_level, as well as the type of edge being processed, will be taken up after we describe the normal loop filtering algorithm below.
上記で使用されているedge_limit値の導出は、loop_filter_levelとsharpness_levelに依存し、処理されるエッジのタイプは、以下の通常のループフィルタリングアルゴリズムを説明した後に取り上げられます。
The normal loop filter is a refinement of the simple loop filter; all of the general discussion above applies here as well. In particular, the functions c, u2s, s2u, abs, and common_adjust are used by both the normal and simple filters.
通常のループフィルターは、単純なループフィルターの改良です。上記の一般的な議論はすべてここにも当てはまります。特に、関数c、u2s、s2u、abs、およびcommon_adjustは、通常と単純なフィルターの両方で使用されます。
As mentioned above, the normal algorithms for inter-macroblock and inter-subblock edges differ. Nonetheless, they have a great deal in common: They use similar threshold algorithms to disable the filter and to detect high internal edge variance (which influences the filtering algorithm). Both algorithms also use, at least conditionally, the simple filter adjustment procedure described above.
上記のように、マクロブロック間およびサブブロック間エッジの通常のアルゴリズムは異なります。それにもかかわらず、それらは非常に共通点があります。同様のしきい値アルゴリズムを使用してフィルターを無効にし、高い内部エッジ分散を検出します（フィルタリングアルゴリズムに影響します）。両方のアルゴリズムは、少なくとも条件付きでは、上記の単純なフィルター調整手順も使用します。
The common thresholding algorithms are as follows.
一般的なしきい値アルゴリズムは次のとおりです。
---- Begin code block --------------------------------------
/* All functions take (among other things) a segment (of length
at most 4 + 4 = 8) symmetrically straddling an edge.
The pixel values (or pointers) are always given in order,
from the "beforemost" to the "aftermost". So, for a
horizontal edge (written "|"), an 8-pixel segment would be
ordered p3 p2 p1 p0 | q0 q1 q2 q3. */
/* Filtering is disabled if the difference between any two
adjacent "interior" pixels in the 8-pixel segment exceeds
the relevant threshold (I). A more complex thresholding
calculation is done for the group of four pixels that
straddle the edge, in line with the calculation in
simple_segment() above. */
int filter_yes(
uint8 I, /* limit on interior differences */
uint8 E, /* limit at the edge */
cint8 p3, cint8 p2, cint8 p1, cint8 p0, /* pixels before
edge */
cint8 q0, cint8 q1, cint8 q2, cint8 q3 /* pixels after
edge */
) {
return (abs(p0 - q0)*2 + abs(p1 - q1)/2) <= E
&& abs(p3 - p2) <= I && abs(p2 - p1) <= I &&
abs(p1 - p0) <= I
&& abs(q3 - q2) <= I && abs(q2 - q1) <= I &&
abs(q1 - q0) <= I;
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/* Filtering is altered if (at least) one of the differences
on either side of the edge exceeds a threshold (we have
"high edge variance"). */
int hev(
uint8 threshold,
cint8 p1, cint8 p0, /* pixels before edge */
cint8 q0, cint8 q1 /* pixels after edge */
) {
return abs(p1 - p0) > threshold || abs(q1 - q0) > threshold;
}
---- End code block ----------------------------------------
The subblock filter is a variant of the simple filter. In fact, if we have high edge variance, the adjustment is exactly as for the simple filter. Otherwise, the simple adjustment (without outer taps) is applied, and the two pixels one step in from the edge pixels are adjusted by roughly half the amount by which the two edge pixels are adjusted; since the edge adjustment here is essentially 3/8 the edge difference, the inner adjustment is approximately 3/16 the edge difference.
サブブロックフィルターは、単純なフィルターのバリアントです。実際、エッジの分散が高い場合、調整は単純なフィルターとまったく同じです。それ以外の場合、単純な調整（外側のタップなし）が適用され、エッジピクセルからの2つのピクセルの1つのステップは、2つのエッジピクセルが調整される約半分の量で調整されます。ここのエッジ調整は本質的に3/8であるため、エッジの差は約3/16のエッジ差です。
---- Begin code block --------------------------------------
void subblock_filter(
uint8 hev_threshold, /* detect high edge variance */
uint8 interior_limit, /* possibly disable filter */
uint8 edge_limit,
cint8 *P3, cint8 *P2, int8 *P1, int8 *P0, /* pixels before
edge */
int8 *Q0, int8 *Q1, cint8 *Q2, cint8 *Q3 /* pixels after
edge */
) {
cint8 p3 = u2s(*P3), p2 = u2s(*P2), p1 = u2s(*P1),
p0 = u2s(*P0);
cint8 q0 = u2s(*Q0), q1 = u2s(*Q1), q2 = u2s(*Q2),
q3 = u2s(*Q3);
if (filter_yes(interior_limit, edge_limit, q3, q2, q1, q0, p0, p1, p2, p3)) { const int hv = hev(hev_threshold, p1, p0, q0, q1);
if（filter_yes（interior_limit、edge_limit、q3、q2、q1、q0、p0、p1、p2、p3））{const int hv = hev（hev_threshold、p1、p0、q0、q1）;
cint8 a = (common_adjust(hv, P1, P0, Q0, Q1) + 1) >> 1;
if (!hv) {
*Q1 = s2u(q1 - a);
*P1 = s2u(p1 + a);
}
}
}
---- End code block ----------------------------------------
The inter-macroblock filter has potentially wider scope. If the edge variance is high, it performs the simple adjustment (using the outer taps, just like the simple filter and the corresponding case of the normal subblock filter). If the edge variance is low, we begin with the same basic filter calculation and apply multiples of it to pixel pairs symmetric about the edge; the magnitude of adjustment decays as we move away from the edge and six of the pixels in the segment are affected.
マクロブロック間フィルターは、潜在的に広いスコープを持っています。エッジの分散が高い場合、単純な調整を実行します（単純なフィルターや通常のサブブロックフィルターの対応するケースと同様に、外側のタップを使用します）。エッジの分散が低い場合、同じ基本的なフィルター計算から始めて、それの倍数をエッジを対称するピクセルペアに適用します。エッジから離れると、調整の大きさが減衰し、セグメント内の6つのピクセルが影響を受けます。
---- Begin code block --------------------------------------
void MBfilter(
uint8 hev_threshold, /* detect high edge variance */
uint8 interior_limit, /* possibly disable filter */
uint8 edge_limit,
cint8 *P3, int8 *P2, int8 *P1, int8 *P0, /* pixels before
edge */
int8 *Q0, int8 *Q1, int8 *Q2, cint8 *Q3 /* pixels after
edge */
) {
cint8 p3 = u2s(*P3), p2 = u2s(*P2), p1 = u2s(*P1),
p0 = u2s(*P0);
cint8 q0 = u2s(*Q0), q1 = u2s(*Q1), q2 = u2s(*Q2),
q3 = u2s(*Q3);
if (filter_yes(interior_limit, edge_limit, q3, q2, q1, q0,
p0, p1, p2, p3))
{
if (!hev(hev_threshold, p1, p0, q0, q1))
{
/* Same as the initial calculation in "common_adjust",
w is something like twice the edge difference */
const int8 w = c(c(p1 - q1) + 3*(q0 - p0));
/* 9/64 is approximately 9/63 = 1/7, and 1<<7 = 128 =
2*64. So this a, used to adjust the pixels adjacent
to the edge, is something like 3/7 the edge
difference. */
int8 a = c((27*w + 63) >> 7);
*Q0 = s2u(q0 - a); *P0 = s2u(p0 + a);
/* Next two are adjusted by 2/7 the edge difference */
a = c((18*w + 63) >> 7);
*Q1 = s2u(q1 - a); *P1 = s2u(p1 + a);
/* Last two are adjusted by 1/7 the edge difference */
a = c((9*w + 63) >> 7);
*Q2 = s2u(q2 - a); *P2 = s2u(p2 + a);
} else /* if hev, do simple filter */
common_adjust(1, P1, P0, Q0, Q1); /* using outer
taps */
}
}
---- End code block ----------------------------------------
We conclude the discussion of loop filtering by showing how the thresholds supplied to the procedures above are derived from the two control parameters sharpness_level (an unsigned 3-bit number having maximum value 7) and loop_filter_level (an unsigned 6-bit number having maximum value 63).
上記の手順に提供されたしきい値が、2つの制御パラメーターSharpness_Level（最大値7を持つ符号なし3ビット数）とloop_filter_level（最大値63を持つ符号なし6ビット数値63を持つ2つの制御パラメーターからどのように導出されるかを示すことにより、ループフィルタリングの議論を締めくくります。）。
While the sharpness_level is constant over the frame, individual macroblocks may override the loop_filter_level with one of four possibilities supplied in the frame header (as described in Section 10).
Sharpness_Levelはフレーム上で一定ですが、個々のマクロブロックは、フレームヘッダーで提供される4つの可能性のいずれかを使用してLOOP_FILTER_LEVELをオーバーライドする場合があります（セクション10で説明されています）。
Both the simple and normal filters disable filtering if a value derived from the four pixels that straddle the edge (2 either side) exceeds a threshold / limit value.
単純なフィルターと通常のフィルターの両方が、エッジにまたがる4つのピクセルから派生した値（2つの側）がしきい値 /制限値を超える場合、フィルタリングを無効にします。
---- Begin code block --------------------------------------
/* Luma and Chroma use the same inter-macroblock edge limit */
uint8 mbedge_limit = ((loop_filter_level + 2) * 2) +
interior_limit;
/* Luma and Chroma use the same inter-subblock edge limit */
uint8 sub_bedge_limit = (loop_filter_level * 2) + interior_limit;
---- End code block ----------------------------------------
The remaining thresholds are used only by the normal filters. The filter-disabling interior difference limit is the same for all edges (luma, chroma, inter-subblock, inter-macroblock) and is given by the following.
残りのしきい値は、通常のフィルターでのみ使用されます。フィルターダイバーの内部差の制限は、すべてのエッジ（Luma、Chroma、Inter-Subblock、Inter-Macroblock）で同じであり、以下で与えられます。
---- Begin code block --------------------------------------
uint8 interior_limit = loop_filter_level;
uint8 interior_limit = loop_filter_level;
if (sharpness_level)
{
interior_limit >>= sharpness_level > 4 ? 2 : 1;
if (interior_limit > 9 - sharpness_level)
interior_limit = 9 - sharpness_level;
}
if (!interior_limit)
interior_limit = 1;
---- End code block ----------------------------------------
Finally, we give the derivation of the high edge-variance threshold, which is also the same for all edge types.
最後に、すべてのエッジタイプでも同じエッジ分散しきい値の導出を与えます。
---- Begin code block --------------------------------------
uint8 hev_threshold = 0;
uint8 hev_threshold = 0;
if (we_are_decoding_akey_frame) /* current frame is a key frame */
{
if (loop_filter_level >= 40)
hev_threshold = 2;
else if (loop_filter_level >= 15)
hev_threshold = 1;
}
else /* current frame is an interframe */
{
if (loop_filter_level >= 40)
hev_threshold = 3;
else if (loop_filter_level >= 20)
hev_threshold = 2;
else if (loop_filter_level >= 15)
hev_threshold = 1;
}
---- End code block ----------------------------------------
We describe the layout and semantics of the prediction records for macroblocks in an interframe.
インターフレームでのマクロブロックの予測記録のレイアウトとセマンティクスについて説明します。
After the feature specification (which is described in Section 10 and is identical for intraframes and interframes), there comes a Bool(prob_intra), which indicates inter-prediction (i.e., prediction from prior frames) when true and intra-prediction (i.e., prediction from already-coded portions of the current frame) when false. The zero-probability prob_intra is set by field J of the frame header.
機能仕様の後（セクション10で説明されており、フレーム内とインターフレームと同一）、ブール（prob_intra）があります。falseの場合、現在のフレームの既にコードされた部分からの予測。Zero Probability Prob_Intraは、フレームヘッダーのフィールドJによって設定されます。
For intra-prediction, the layout of the prediction data is essentially the same as the layout for key frames, although the contexts used by the decoding process are slightly different.
予測内では、予測データのレイアウトは本質的にキーフレームのレイアウトと同じですが、デコードプロセスで使用されるコンテキストはわずかに異なります。
As discussed in Section 8, the "outer" Y mode here uses a different tree from that used in key frames, repeated here for convenience.
セクション8で説明したように、ここでの「外側」Yモードは、キーフレームで使用されているものとは異なるツリーを使用しており、ここで繰り返して便利にします。
---- Begin code block --------------------------------------
const tree_index ymode_tree [2 * (num_ymodes - 1)] =
{
-DC_PRED, 2, /* root: DC_PRED = "0", "1" subtree */
4, 6, /* "1" subtree has 2 descendant subtrees */
-V_PRED, -H_PRED, /* "10" subtree: V_PRED = "100",
H_PRED = "101" */
-TM_PRED, -B_PRED /* "11" subtree: TM_PRED = "110",
B_PRED = "111" */
};
---- End code block ----------------------------------------
The probability table used to decode this tree is variable. As described in Section 11, it (along with the similarly treated UV table) can be updated by field J of the frame header. Similar to the coefficient-decoding probabilities, such updates are cumulative and affect all ensuing frames until the next key frame or explicit update. The default probabilities for the Y and UV tables are:
このツリーをデコードするために使用される確率テーブルは可変です。セクション11で説明されているように、それは（同様に処理されたUVテーブルとともに）フレームヘッダーのフィールドJによって更新できます。係数を解決する確率と同様に、このような更新は累積的であり、次のキーフレームまたは明示的な更新まで、すべての次のフレームに影響します。YおよびUVテーブルのデフォルトの確率は次のとおりです。
---- Begin code block --------------------------------------
Prob ymode_prob [num_ymodes - 1] = { 112, 86, 140, 37};
Prob uv_mode_prob [num_uv_modes - 1] = { 162, 101, 204};
---- End code block ----------------------------------------
These defaults must be restored after detection of a key frame.
これらのデフォルトは、キーフレームの検出後に復元する必要があります。
Just as for key frames, if the Y mode is B_PRED, there next comes an encoding of the intra_bpred mode used by each of the sixteen Y subblocks. These encodings use the same tree as does that for key frames but, in place of the contexts used in key frames, these encodings use the single fixed probability table.
キーフレームと同様に、YモードがB_PREDの場合、次に、16のYサブブロックのそれぞれが使用するIntra_BPREDモードのエンコードがあります。これらのエンコーディングは、キーフレームの場合と同じツリーを使用しますが、キーフレームで使用されるコンテキストの代わりに、これらのエンコードは単一の固定確率テーブルを使用します。
---- Begin code block --------------------------------------
const Prob bmode_prob [num_intra_bmodes - 1] = {
120, 90, 79, 133, 87, 85, 80, 111, 151
};
---- End code block ----------------------------------------
Last comes the chroma mode, again coded using the same tree as that used for key frames, this time using the dynamic uv_mode_prob table described above.
最後に、キーフレームに使用されたものと同じツリーを使用して再びコード化されたChromaモードがあります。今回は、上記の動的uv_mode_probテーブルを使用します。
The calculation of the intra-prediction buffer is identical to that described for key frames in Section 12.
予測内バッファーの計算は、セクション12のキーフレームについて説明したものと同じです。
Otherwise (when the above bool is true), we are using inter-prediction (which of course only happens for interframes), to which we now restrict our attention.
それ以外の場合は（上記のブールが真である場合）、私たちは相互否認（もちろん、インターフレームでのみ発生する）を使用しており、今では注意を制限しています。
The next datum is then another bool, B(prob_last), selecting the reference frame. If 0, the reference frame is the previous frame (the last frame); if 1, another bool (prob_gf) selects the reference frame between the golden frame (0) and the altref frame (1). The probabilities prob_last and prob_gf are set in field J of the frame header.
次のデータムは、参照フレームを選択する別のブールb（prob_last）です。0の場合、参照フレームは前のフレーム（最後のフレーム）です。1の場合、別のブール（prob_gf）は、ゴールデンフレーム（0）とアルトレフフレーム（1）の間の参照フレームを選択します。確率fictives_lastとprob_gfは、フレームヘッダーのフィールドJに設定されています。
Together with setting the reference frame, the purpose of inter-mode decoding is to set a motion vector for each of the sixteen Y subblocks of the current macroblock. These settings then define the calculation of the inter-prediction buffer (detailed in Section 18). While the net effect of inter-mode decoding is straightforward, the implementation is somewhat complex; the (lossless) compression achieved by this method justifies the complexity.
参照フレームの設定とともに、インターモードデコードの目的は、現在のマクロブロックの16 Yサブブロックのそれぞれにモーションベクトルを設定することです。これらの設定は、予測間バッファーの計算を定義します（セクション18で詳細）。インターモードデコードの正味の効果は簡単ですが、実装はやや複雑です。この方法によって達成される（ロスレス）圧縮は、複雑さを正当化します。
After the reference frame selector comes the mode (or motion vector reference) applied to the macroblock as a whole, coded using the following enumeration and tree. Setting mv_nearest = num_ymodes is a convenience that allows a single variable to unambiguously hold an inter- or intra-prediction mode.
参照フレームセレクターには、マクロブロック全体に適用されるモード（またはモーションベクトル参照）があり、次の列挙とツリーを使用してコード化されます。MV_NEARest = num_ymodesの設定は、単一の変数が予測内または内容モードを明確に保持できるようにする便利さです。
---- Begin code block --------------------------------------
typedef enum
{
mv_nearest = num_ymodes, /* use "nearest" motion vector
for entire MB */
mv_near, /* use "next nearest" "" */
mv_zero, /* use zero "" */
mv_new, /* use explicit offset from
implicit "" */
mv_split, /* use multiple motion vectors */
num_mv_refs = mv_split + 1 - mv_nearest
}
mv_ref;
const tree_index mv_ref_tree [2 * (num_mv_refs - 1)] =
{
-mv_zero, 2, /* zero = "0" */
-mv_nearest, 4, /* nearest = "10" */
-mv_near, 6, /* near = "110" */
-mv_new, -mv_split /* new = "1110", split = "1111" */
};
---- End code block ----------------------------------------
The probability table used to decode the mv_ref, along with three reference motion vectors used by the selected mode, is calculated via a survey of the already-decoded motion vectors in (up to) 3 nearby macroblocks.
選択したモードで使用される3つの参照モーションベクトルとともに、MV_REFをデコードするために使用される確率表は、（最大）3つのマクロブロックの既にゼロのモーションベクトルの調査を介して計算されます。
The algorithm generates a sorted list of distinct motion vectors adjacent to the search site. The best_mv is the vector with the highest score. The mv_nearest is the non-zero vector with the highest score. The mv_near is the non-zero vector with the next highest score. The number of motion vectors coded using the SPLITMV mode is scored using the same weighting and is returned with the scores of the best, nearest, and near vectors.
アルゴリズムは、検索サイトに隣接する個別のモーションベクトルのソート付きリストを生成します。Best_MVは、最高スコアのベクトルです。MV_NEARESTは、最高スコアを持つ非ゼロベクトルです。MV_NEARは、次に最高のスコアを持つ非ゼロベクトルです。SplitMVモードを使用してコード化されたモーションベクトルの数は、同じ重み付けを使用してスコアリングされ、ベクターに近いベクターのスコアで返されます。
The three adjacent macroblocks above, left, and above-left are considered in order. If the macroblock is intra-coded, no action is taken. Otherwise, the motion vector is compared to other previously found motion vectors to determine if it has been seen before, and if so contributes its weight to that vector; otherwise, it enters a new vector in the list. The above and left vectors have twice the weight of the above-left vector.
上の3つの隣接するマクロブロック、左、および左以上のマクロブロックが順番に考慮されます。マクロブロックがコード内にある場合、アクションは実行されません。それ以外の場合、モーションベクトルは、以前に見つかった他のモーションベクトルと比較され、以前に見られたかどうか、およびそのベクトルにその重量を寄付するかどうかを判断します。それ以外の場合は、リスト内の新しいベクトルに入ります。上記のベクトルと左ベクトルには、左上のベクトルの2倍の重量があります。
As is the case with many contexts used by VP8, it is possible for macroblocks near the top or left edges of the image to reference blocks that are outside the visible image. VP8 provides a border of 1 macroblock filled with 0x0 motion vectors left of the left edge, and a border filled with 0,0 motion vectors of 1 macroblocks above the top edge.
VP8で使用されている多くのコンテキストがある場合と同様に、画像の上部または左エッジの近くにマクロブロックが表示され、可視画像の外側にあるブロックを参照する可能性があります。VP8は、左端の左左の0x0モーションベクトルで満たされた1つのマクロブロックの境界線と、上端の1つのマクロブロックの0,0モーションベクトルで満たされた境界線を提供します。
Much of the process is more easily described in C than in English. The reference code for this can be found in modemv.c (Section 20.11). The calculation of reference vectors, probability table, and, finally, the inter-prediction mode itself is implemented as follows.
プロセスの多くは、英語よりもCで簡単に説明されています。このための参照コードは、modemv.c（セクション20.11）にあります。参照ベクトル、確率表、および最後に、予測間モード自体の計算は、次のように実装されます。
---- Begin code block --------------------------------------
typedef union
{
unsigned int as_int;
MV as_mv;
} int_mv; /* facilitates rapid equality tests */
static void mv_bias(MODE_INFO *x,int refframe, int_mv *mvp,
int * ref_frame_sign_bias)
{
MV xmv;
xmv = x->mbmi.mv.as_mv;
if ( ref_frame_sign_bias[x->mbmi.ref_frame] !=
ref_frame_sign_bias[refframe] )
{
xmv.row*=-1;
xmv.col*=-1;
}
mvp->as_mv = xmv;
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
void vp8_clamp_mv(MV *mv, const MACROBLOCKD *xd)
{
if ( mv->col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN) )
mv->col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
else if ( mv->col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN )
mv->col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
if ( mv->row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN) )
mv->row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
else if ( mv->row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN )
mv->row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
}
---- End code block ----------------------------------------
In the function vp8_find_near_mvs(), the vectors "nearest" and "near" are used by the corresponding modes.
関数vp8_find_near_mvs（）では、ベクトル「最も近い」および「近く」が対応するモードで使用されます。
The vector best_mv is used as a base for explicitly coded motion vectors.
Vector Best_MVは、明示的にコーディングされたモーションベクトルのベースとして使用されます。
The first three entries in the return value cnt are (in order) weighted census values for "zero", "nearest", and "near" vectors. The final value indicates the extent to which SPLITMV was used by the neighboring macroblocks. The largest possible "weight" value in each case is 5.
戻り値CNTの最初の3つのエントリは、「ゼロ」、「最も近い」、および「近く」ベクトルの（順に）加重された国勢調査値です。最終的な値は、隣接するマクロブロックによってsplitMVが使用された程度を示します。それぞれの場合に可能な最大の「重量」値は5です。
---- Begin code block --------------------------------------
void vp8_find_near_mvs ( MACROBLOCKD *xd, const MODE_INFO *here, MV *nearest, MV *near, MV *best_mv, int cnt[4], int refframe, int * ref_frame_sign_bias )
void vp8_find_near_mvs（macroblockd *xd、const mode_info *here、mv *最も近い、mv *近く、mv *best_mv、int cnt [4]、int refframe、int *ref_frame_sign_bias）
{
const MODE_INFO *above = here - xd->mode_info_stride;
const MODE_INFO *left = here - 1;
const MODE_INFO *aboveleft = above - 1;
int_mv near_mvs[4];
int_mv *mv = near_mvs;
int *cntx = cnt;
enum {CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV};
/* Zero accumulators */
mv[0].as_int = mv[1].as_int = mv[2].as_int = 0;
cnt[0] = cnt[1] = cnt[2] = cnt[3] = 0;
/* Process above */
if (above->mbmi.ref_frame != INTRA_FRAME) {
if (above->mbmi.mv.as_int) {
(++mv)->as_int = above->mbmi.mv.as_int;
mv_bias(above, refframe, mv, ref_frame_sign_bias);
++cntx;
}
*cntx += 2;
}
/* Process left */
if (left->mbmi.ref_frame != INTRA_FRAME) {
if (left->mbmi.mv.as_int) {
int_mv this_mv;
this_mv.as_int = left->mbmi.mv.as_int;
mv_bias(left, refframe, &this_mv, ref_frame_sign_bias);
if (this_mv.as_int != mv->as_int) {
(++mv)->as_int = this_mv.as_int;
++cntx;
}
*cntx += 2;
} else
cnt[CNT_ZERO] += 2;
}
/* Process above left */
if (aboveleft->mbmi.ref_frame != INTRA_FRAME) {
if (aboveleft->mbmi.mv.as_int) {
int_mv this_mv;
this_mv.as_int = aboveleft->mbmi.mv.as_int;
mv_bias(aboveleft, refframe, &this_mv,
ref_frame_sign_bias);
if (this_mv.as_int != mv->as_int) {
(++mv)->as_int = this_mv.as_int;
++cntx;
}
*cntx += 1;
} else
cnt[CNT_ZERO] += 1;
}
/* If we have three distinct MVs ... */
if (cnt[CNT_SPLITMV]) {
/* See if above-left MV can be merged with NEAREST */
if (mv->as_int == near_mvs[CNT_NEAREST].as_int)
cnt[CNT_NEAREST] += 1;
}
cnt[CNT_SPLITMV] = ((above->mbmi.mode == SPLITMV)
+ (left->mbmi.mode == SPLITMV)) * 2
+ (aboveleft->mbmi.mode == SPLITMV);
/* Swap near and nearest if necessary */
if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
int tmp;
tmp = cnt[CNT_NEAREST];
cnt[CNT_NEAREST] = cnt[CNT_NEAR];
cnt[CNT_NEAR] = tmp;
tmp = near_mvs[CNT_NEAREST].as_int;
near_mvs[CNT_NEAREST].as_int = near_mvs[CNT_NEAR].as_int;
near_mvs[CNT_NEAR].as_int = tmp;
}
/* Use near_mvs[0] to store the "best" MV */
if (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])
near_mvs[CNT_ZERO] = near_mvs[CNT_NEAREST];
/* Set up return values */
*best_mv = near_mvs[0].as_mv;
*nearest = near_mvs[CNT_NEAREST].as_mv;
*near = near_mvs[CNT_NEAR].as_mv;
vp8_clamp_mv(nearest, xd);
vp8_clamp_mv(near, xd);
vp8_clamp_mv(best_mv, xd); //TODO: Move this up before
the copy
}
---- End code block ----------------------------------------
The mv_ref probability table (mv_ref_p) is then derived from the census as follows.
MV_REF確率表（MV_REF_P）は、次のように国勢調査から派生します。
---- Begin code block --------------------------------------
const int vp8_mode_contexts[6][4] =
{
{ 7, 1, 1, 143, },
{ 14, 18, 14, 107, },
{ 135, 64, 57, 68, },
{ 60, 56, 128, 65, },
{ 159, 134, 128, 34, },
{ 234, 188, 128, 28, },
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
vp8_prob *vp8_mv_ref_probs(vp8_prob mv_ref_p[VP8_MVREFS-1],
int cnt[4])
{
mv_ref_p[0] = vp8_mode_contexts [cnt[0]] [0];
mv_ref_p[1] = vp8_mode_contexts [cnt[1]] [1];
mv_ref_p[2] = vp8_mode_contexts [cnt[2]] [2];
mv_ref_p[3] = vp8_mode_contexts [cnt[3]] [3];
return p;
}
---- End code block ----------------------------------------
Once mv_ref_p is established, the mv_ref is decoded as usual.
MV_REF_Pが確立されると、MV_REFは通常どおりデコードされます。
---- Begin code block --------------------------------------
mvr = (mv_ref) treed_read(d, mv_ref_tree, mv_ref_p);
---- End code block ----------------------------------------
For the first four inter-coding modes, the same motion vector is used for all the Y subblocks. The first three modes use an implicit motion vector.
最初の4つのインターコードモードでは、すべてのYサブブロックに同じモーションベクトルが使用されます。最初の3つのモードでは、暗黙の動きベクトルを使用します。
+------------+------------------------------------------------------+
| Mode | Instruction |
+------------+------------------------------------------------------+
| mv_nearest | Use the nearest vector returned by |
| | vp8_find_near_mvs. |
| | |
| mv_near | Use the near vector returned by vp8_find_near_mvs. |
| | |
| mv_zero | Use a zero vector; that is, predict the current |
| | macroblock from the corresponding macroblock in the |
| | prediction frame. |
| | |
| NEWMV | This mode is followed by an explicitly coded motion |
| | vector (the format of which is described in the next |
| | section) that is added (component-wise) to the |
| | best_mv reference vector returned by find_near_mvs |
| | and applied to all 16 subblocks. |
+------------+------------------------------------------------------+
The remaining mode (SPLITMV) causes multiple vectors to be applied to the Y subblocks. It is immediately followed by a partition specification that determines how many vectors will be specified and how they will be assigned to the subblocks. The possible partitions, with indicated subdivisions and coding tree, are as follows.
残りのモード（splitMV）により、複数のベクトルがyサブブロックに適用されます。すぐに、指定されるベクトルの数とサブブロックにどのように割り当てられるかを決定するパーティション仕様が続きます。示された下位区分とコーディングツリーを備えた可能性のあるパーティションは、次のとおりです。
---- Begin code block --------------------------------------
typedef enum
{
mv_top_bottom, /* two pieces {0...7} and {8...15} */
mv_left_right, /* {0,1,4,5,8,9,12,13} and
{2,3,6,7,10,11,14,15} */
mv_quarters, /* {0,1,4,5}, {2,3,6,7}, {8,9,12,13},
{10,11,14,15} */
MV_16, /* every subblock gets its own vector
{0} ... {15} */
mv_num_partitions } MVpartition;
MV_NUM_PARTITIONS} MVPartition;
const tree_index mvpartition_tree [2 * (mvnum_partition - 1)] =
{
-MV_16, 2, /* MV_16 = "0" */
-mv_quarters, 4, /* mv_quarters = "10" */
-mv_top_bottom, -mv_left_right /* top_bottom = "110",
left_right = "111" */
};
---- End code block ----------------------------------------
The partition is decoded using a fixed, constant probability table:
パーティションは、固定された一定の確率表を使用してデコードされます。
---- Begin code block --------------------------------------
const Prob mvpartition_probs [mvnum_partition - 1] =
{ 110, 111, 150};
part = (MVpartition) treed_read(d, mvpartition_tree,
mvpartition_probs);
---- End code block ----------------------------------------
After the partition come two (for mv_top_bottom or mv_left_right), four (for mv_quarters), or sixteen (for MV_16) subblock inter-prediction modes. These modes occur in the order indicated by the partition layouts (given as comments to the MVpartition enum) and are coded as follows. (As was done for the macroblock-level modes, we offset the mode enumeration so that a single variable may unambiguously hold either an intra- or inter-subblock mode.)
パーティションが2つ（MV_TOP_BOTTOMまたはMV_LEFT_RIGHTの場合）、4つ（MV_QUARTERSの場合）、または16（MV_16の場合）サブブロック相間モードになります。これらのモードは、パーティションレイアウトで示された順序で発生します（MVPARTITION列挙へのコメントとして与えられます）、次のようにコーディングされます。（マクロブロックレベルのモードで行われたように、単一の変数がイントラブロックモードまたはインターサブブロックモードのいずれかを明確に保持できるようにモード列挙を相殺します。）
Prior to decoding each subblock, a decoding tree context is chosen as illustrated in the code snippet below. The context is based on the immediate left and above subblock neighbors, and whether they are equal, are zero, or a combination of those.
各サブブロックをデコードする前に、以下のコードスニペットに示されているように、デコードツリーコンテキストが選択されます。コンテキストは、左の左以降のサブブロックネイバーに基づいており、それらが等しいかどうかはゼロ、またはそれらの組み合わせです。
---- Begin code block --------------------------------------
typedef enum
{
LEFT4x4 = num_intra_bmodes, /* use already-coded MV to
my left */
ABOVE4x4, /* use already-coded MV above me */
ZERO4x4, /* use zero MV */
NEW4x4, /* explicit offset from "best" */
num_sub_mv_ref }; sub_mv_ref;
num_sub_mv_ref};sub_mv_ref;
const tree_index sub_mv_ref_tree [2 * (num_sub_mv_ref - 1)] =
{
-LEFT4X4, 2, /* LEFT = "0" */
-ABOVE4X4, 4, /* ABOVE = "10" */
-ZERO4X4, -NEW4X4 /* ZERO = "110", NEW = "111" */
};
/* Choose correct decoding tree context
* Function parameters are left subblock neighbor MV and above
* subblock neighbor MV */
int vp8_mvCont(MV *l, MV*a)
{
int lez = (l->row == 0 && l->col == 0); /* left neighbor
is zero */
int aez = (a->row == 0 && a->col == 0); /* above neighbor
is zero */
int lea = (l->row == a->row && l->col == a->col); /* left
neighbor equals above neighbor */
if (lea && lez)
return SUBMVREF_LEFT_ABOVE_ZED; /* =4 */
if (lea)
return SUBMVREF_LEFT_ABOVE_SAME; /* =3 */
if (aez)
return SUBMVREF_ABOVE_ZED; /* =2 */
if (lez)
return SUBMVREF_LEFT_ZED; /* =1*/
return SUBMVREF_NORMAL; /* =0 */
}
/* Constant probabilities and decoding procedure. */
const Prob sub_mv_ref_prob [5][num_sub_mv_ref - 1] = {
{ 147,136,18 },
{ 106,145,1 },
{ 179,121,1 },
{ 223,1 ,34 },
{ 208,1 ,1 }
};
sub_ref = (sub_mv_ref) treed_read(d, sub_mv_ref_tree,
sub_mv_ref_prob[context]);
---- End code block ----------------------------------------
The first two sub-prediction modes simply copy the already-coded motion vectors used by the blocks above and to the left of the subblock at the upper left corner of the current subset (i.e., collection of subblocks being predicted). These prediction blocks need not lie in the current macroblock and, if the current subset lies at the top or left edges of the frame, need not lie in the frame. In this latter case, their motion vectors are taken to be zero, as are subblock motion vectors within an intra-predicted macroblock. Also, to ensure the correctness of prediction within this macroblock, all subblocks lying in an already-decoded subset of the current macroblock must have their motion vectors set.
最初の2つのサブ予測モードは、現在のサブセットの左上隅にあるサブブロックの左側と左側のブロック（つまり、予測されるサブブロックのコレクション）で使用される既にコードされたモーションベクトルを単純にコピーします。これらの予測ブロックは、現在のマクロブロックにある必要はなく、現在のサブセットがフレームの上部または左のエッジにある場合、フレームにある必要はありません。この後者の場合、彼らのモーションベクトルは、予測内マクロブロック内のサブブロックモーションベクトルと同様に、ゼロと見なされます。また、このマクロブロック内の予測の正確性を確保するには、現在のマクロブロックの既に説明されているサブセットにあるすべてのサブブロックがモーションベクトルを設定する必要があります。
ZERO4x4 uses a zero motion vector and predicts the current subset using the corresponding subset from the prediction frame.
zero4x4はゼロモーションベクトルを使用し、予測フレームから対応するサブセットを使用して現在のサブセットを予測します。
NEW4x4 is exactly like NEWMV except that NEW4x4 is applied only to the current subset. It is followed by a two-dimensional motion vector offset (described in the next section) that is added to the best vector returned by the earlier call to find_near_mvs to form the motion vector in effect for the subset.
New4x4は、New4x4が現在のサブセットにのみ適用されることを除いて、まったくnewMVとまったく同じです。その後、2次元のモーションベクトルオフセット（次のセクションで説明）が続き、FIND_NEAR_MVSの以前の呼び出しによって返された最高のベクトルに追加され、サブセットのモーションベクトルを形成します。
Parsing of both inter-prediction modes and motion vectors (described next) can be found in the reference decoder file modemv.c (Section 20.11).
予測間モードとモーションベクトルの両方の解析（次に説明）は、参照デコーダーファイルmodemv.c（セクション20.11）に記載されています。
As discussed above, motion vectors appear in two places in the VP8 datastream: applied to whole macroblocks in NEWMV mode and applied to subsets of macroblocks in NEW4x4 mode. The format of the vectors is identical in both cases.
上記で説明したように、モーションベクトルはVP8 DataStreamの2つの場所に表示されます。NewMVモードでマクロブロック全体に適用され、New4X4モードのマクロブロックのサブセットに適用されます。ベクトルの形式は、どちらの場合も同一です。
Each vector has two pieces: a vertical component (row) followed by a horizontal component (column). The row and column use separate coding probabilities but are otherwise represented identically.
各ベクトルには、垂直コンポーネント（行）に続いて水平成分（列）が2つあります。行と列は個別のコーディング確率を使用しますが、それ以外の場合は同じように表されます。
Each component is a signed integer V representing a vertical or horizontal luma displacement of V quarter-pixels (and a chroma displacement of V eighth-pixels). The absolute value of V, if non-zero, is followed by a boolean sign. V may take any value between -1023 and +1023, inclusive.
各コンポーネントは、V四半期ピクセルの垂直または水平ルマの変位（およびV 8番目のピクセルのクロマ変位）を表す署名された整数Vです。Vの絶対値は、非ゼロの場合、ブールサインが続きます。vは、-1023から1023の間の任意の値を包括的にすることができます。
The absolute value A is coded in one of two different ways according to its size. For 0 <= A <= 7, A is tree-coded, and for 8 <= A <= 1023, the bits in the binary expansion of A are coded using independent boolean probabilities. The coding of A begins with a bool specifying which range is in effect.
絶対値Aは、そのサイズに応じて2つの異なる方法のいずれかでコーディングされます。0 <= a <= 7の場合、aはツリーコードされ、8 <= a <= 1023の場合、aのバイナリ拡張のビットは独立したブールの確率を使用してコード化されます。Aのコーディングは、どの範囲が有効であるかを指定するブールから始まります。
Decoding a motion vector component then requires a 19-position probability table, whose offsets, along with the procedure used to decode components, are as follows:
モーションベクトルコンポーネントをデコードするには、コンポーネントをデコードするために使用される手順とともに、オフセットが次のように、19位の確率テーブルが必要です。
---- Begin code block --------------------------------------
typedef enum
{
mvpis_short, /* short (<= 7) vs long (>= 8) */
MVPsign, /* sign for non-zero */
MVPshort, /* 8 short values = 7-position tree */
MVPbits = MVPshort + 7, /* 8 long value bits
w/independent probs */
MVPcount = MVPbits + 10 /* 19 probabilities in total */
}
MVPindices;
typedef Prob MV_CONTEXT [MVPcount]; /* Decoding spec for
a single component */
/* Tree used for small absolute values (has expected
correspondence). */
const tree_index small_mvtree [2 * (8 - 1)] =
{
2, 8, /* "0" subtree, "1" subtree */
4, 6, /* "00" subtree, "01" subtree */
-0, -1, /* 0 = "000", 1 = "001" */
-2, -3, /* 2 = "010", 3 = "011" */
10, 12, /* "10" subtree, "11" subtree */
-4, -5, /* 4 = "100", 5 = "101" */
-6, -7 /* 6 = "110", 7 = "111" */
};
/* Read MV component at current decoder position, using
supplied probs. */
int read_mvcomponent(bool_decoder *d, const MV_CONTEXT *mvc)
{
const Prob * const p = (const Prob *) mvc;
int A = 0;
int a = 0;
if (read_bool(d, p [mvpis_short])) /* 8 <= A <= 1023 */
{
/* Read bits 0, 1, 2 */
int i = 0;
do { A += read_bool(d, p [MVPbits + i]) << i;}
while (++i < 3);
/* Read bits 9, 8, 7, 6, 5, 4 */
i = 9;
do { A += read_bool(d, p [MVPbits + i]) << i;}
while (--i > 3);
/* We know that A >= 8 because it is coded long,
so if A <= 15, bit 3 is one and is not
explicitly coded. */
if (!(A & 0xfff0) || read_bool(d, p [MVPbits + 3]))
A += 8;
}
else /* 0 <= A <= 7 */
A = treed_read(d, small_mvtree, p + MVPshort);
return A && read_bool(r, p [MVPsign]) ? -A : A;
}
---- End code block ----------------------------------------
The decoder should maintain an array of two MV_CONTEXTs for decoding row and column components, respectively. These MV_CONTEXTs should be set to their defaults every key frame. Each individual probability may be updated every interframe (by field J of the frame header) using a constant table of update probabilities. Each optional update is of the form B? P(7), that is, a bool followed by a 7-bit probability specification if true.
デコーダーは、それぞれ行と列コンポーネントをデコードするために、2つのMV_Contextsの配列を維持する必要があります。これらのMV_Contextは、すべてのキーフレームのデフォルトに設定する必要があります。個々の確率は、更新確率の定数テーブルを使用して、すべてのインターフレーム（フレームヘッダーのフィールドJによって）を更新できます。各オプションの更新はフォームBのものですか？p（7）、つまり、ブールに続いて7ビット確率仕様がtrueの場合。
As with other dynamic probabilities used by VP8, the updates remain in effect until the next key frame or until replaced via another update.
VP8が使用する他の動的確率と同様に、更新は次のキーフレームまで、または別の更新を介して置き換えるまで有効です。
In detail, the probabilities should then be managed as follows.
詳細には、確率を次のように管理する必要があります。
---- Begin code block --------------------------------------
/* Never-changing table of update probabilities for each
individual probability used in decoding motion vectors. */
const MV_CONTEXT vp8_mv_update_probs[2] =
{
{
237,
246,
253, 253, 254, 254, 254, 254, 254,
254, 254, 254, 254, 254, 250, 250, 252, 254, 254
},
{
231,
243,
245, 253, 254, 254, 254, 254, 254,
254, 254, 254, 254, 254, 251, 251, 254, 254, 254
}
};
/* Default MV decoding probabilities. */
const MV_CONTEXT default_mv_context[2] = { { // row 162, // is short 128, // sign 225, 146, 172, 147, 214, 39, 156, // short tree 128, 129, 132, 75, 145, 178, 206, 239, 254, 254 // long bits },
const mv_context default_mv_context [2] = {{// row 162、// is short 128、// sign 225、146、172、147、214、39、156、//短いツリー128、129、132、75、145、178、206、239、254、254 //ロングビット}、
{ // same for column 164, // is short 128, 204, 170, 119, 235, 140, 230, 228, 128, 130, 130, 74, 148, 180, 203, 236, 254, 254 // long bits
{//列164、//は短い128、204、170、119、235、140、230、228、128、130、130、74、148、180、203、236、254、254 //長い//ビット
} };
}};
/* Current MV decoding probabilities, set to above defaults
every key frame. */
MV_CONTEXT mvc [2]; /* always row, then column */
/* Procedure for decoding a complete motion vector. */
typedef struct { int16 row, col;} MV; /* as in previous section */
MV read_mv(bool_decoder *d)
{
MV v;
v.row = (int16) read_mvcomponent(d, mvc);
v.col = (int16) read_mvcomponent(d, mvc + 1);
return v;
}
/* Procedure for updating MV decoding probabilities, called
every interframe with "d" at the appropriate position in
the frame header. */
void update_mvcontexts(bool_decoder *d)
{
int i = 0;
do { /* component = row, then column */
const Prob *up = mv_update_probs[i]; /* update probs
for component */
Prob *p = mvc[i]; /* start decode tbl "" */
Prob * const pstop = p + MVPcount; /* end decode tbl "" */
do {
if (read_bool(d, *up++)) /* update this position */
{
const Prob x = read_literal(d, 7);
*p = x? x<<1 : 1;
}
} while (++p < pstop); /* next position */
} while (++i < 2); /* next component */
}
---- End code block ----------------------------------------
This completes the description of the motion-vector decoding procedure and, with it, the procedure for decoding interframe macroblock prediction records.
これにより、モーションベクトルデコード手順の説明と、それに伴い、インターフレームマクロブロック予測記録をデコードする手順が記入されます。
Given an inter-prediction specification for the current macroblock, that is, a reference frame together with a motion vector for each of the sixteen Y subblocks, we describe the calculation of the prediction buffer for the macroblock. Frame reconstruction is then completed via the previously described processes of residue summation (Section 14) and loop filtering (Section 15).
現在のマクロブロックの予測間仕様、つまり16 Yの各サブブロックのモーションベクトルと一緒に参照フレームが与えられている場合、マクロブロックの予測バッファーの計算について説明します。その後、フレームの再構築は、以前に記載された残基合計（セクション14）およびループフィルタリング（セクション15）のプロセスを介して完了します。
The management of inter-predicted subblocks and sub-pixel interpolation may be found in the reference decoder file predict.c (Section 20.14).
相互予測されたサブブロックとサブピクセル補間の管理は、参照デコーダーファイルPredict.C（セクション20.14）に記載されている場合があります。
Since each motion vector is differentially encoded from a neighboring block or macroblock and the only clamp is to ensure that the referenced motion vector represents a valid location inside a reference frame buffer, it is technically possible within the VP8 format for a block or macroblock to have arbitrarily large motion vectors, up to the size of the input image plus the extended border areas. For practical reasons, VP8 imposes a motion vector size range limit of -4096 to 4095 full pixels, regardless of image size (VP8 defines 14 raw bits for width and height; 16383x16383 is the maximum possible image size). Bitstream-compliant encoders and decoders shall enforce this limit.
各モーションベクトルは隣接するブロックまたはマクロブロックから差次的にエンコードされており、唯一のクランプは参照される動きベクトルが参照フレームバッファ内の有効な位置を表すことを確認することです。ブロックまたはマクロブロックのVP8形式内で技術的に可能です入力画像のサイズと拡張ボーダーエリアまでの任意の大きなモーションベクトル。実際的な理由で、VP8は、画像サイズに関係なく、動きベクトルサイズ範囲の-4096〜4095フルピクセルを課します（VP8は幅と高さの14個の生ビットを定義します; 16383X16383は可能な限り最大の画像サイズです）。BitStreamに準拠したエンコーダーとデコーダーは、この制限を実施するものとします。
Because the motion vectors applied to the chroma subblocks have 1/8-pixel resolution, the synthetic pixel calculation, outlined in Section 5 and detailed below, uses this resolution for the luma subblocks as well. In accordance, the stored luma motion vectors are all doubled, each component of each luma vector becoming an even integer in the range -2046 to +2046, inclusive.
クロマサブブロックに適用される動きベクターは1/8ピクセルの解像度を持っているため、セクション5で概説され、以下に詳細に概説されている合成ピクセル計算では、LUMAサブブロックにもこの解像度を使用しています。それに応じて、保存されたLumaモーションベクトルはすべて2倍になり、各Lumaベクターの各コンポーネントは、2046〜2046の範囲の均一な整数になります。
The vector applied to each chroma subblock is calculated by averaging the vectors for the 4 luma subblocks occupying the same visible area as the chroma subblock in the usual correspondence; that is, the vector for U and V block 0 is the average of the vectors for the Y subblocks { 0, 1, 4, 5}, chroma block 1 corresponds to Y blocks { 2, 3, 6, 7}, chroma block 2 to Y blocks { 8, 9, 12, 13}, and chroma block 3 to Y blocks { 10, 11, 14, 15}.
各クロマサブブロックに適用されるベクトルは、通常の対応でクロマサブブロックと同じ可視領域を占める4つのLUMAサブブロックのベクトルを平均化することによって計算されます。つまり、uとvブロック0のベクトルは、yサブブロックのベクトルの平均{0、1、4、5}、クロマブロック1はyブロック{2、3、6、7}、クロマブロックに対応します。2からYブロック{8、9、12、13}、およびChromaブロック3からYブロック{10、11、14、15}。
In detail, each of the two components of the vectors for each of the chroma subblocks is calculated from the corresponding luma vector components as follows:
詳細には、各クロマサブブロックのベクトルの2つのコンポーネントのそれぞれは、次のように対応するLUMAベクターコンポーネントから計算されます。
---- Begin code block --------------------------------------
int avg(int c1, int c2, int c3, int c4)
{
int s = c1 + c2 + c3 + c4;
/* The shift divides by 8 (not 4) because chroma pixels
have twice the diameter of luma pixels. The handling
of negative motion vector components is slightly
cumbersome because, strictly speaking, right shifts
of negative numbers are not well-defined in C. */
return s >= 0 ? (s + 4) >> 3 : -((-s + 4) >> 3);
}
---- End code block ----------------------------------------
Furthermore, if the version number in the frame tag specifies only full-pel chroma motion vectors, then the fractional parts of both components of the vector are truncated to zero, as illustrated in the following pseudocode (assuming 3 bits of fraction for both luma and chroma vectors):
さらに、フレームタグのバージョン番号がフルペルクロマモーションベクトルのみを指定した場合、次の擬似コードに示されているように、ベクターの両方のコンポーネントの分数部分がゼロに切り捨てられます（Lumaと両方の分数で3ビットの分数を想定しています。クロマベクター）：
---- Begin code block --------------------------------------
x = x & (~7);
y = y & (~7);
---- End code block ----------------------------------------
Earlier in this document we described the vp8_clamp_mv() function to limit "nearest" and "near" motion vector predictors inside specified margins within the frame boundaries. Additional clamping is performed for NEWMV macroblocks, for which the final motion vector is clamped again after combining the "best" predictor and the differential vector decoded from the stream.
このドキュメントの早い段階で、VP8_CLAMP_MV（）関数について説明し、フレーム境界内の指定されたマージン内の「最も近い」および「近く」モーションベクトル予測子を制限しました。NewMVマクロブロックに対して追加のクランプが実行されます。このクランプは、「最良の」予測因子とストリームからデコードされた微分ベクトルを組み合わせた後、再び最終運動ベクトルが再びクランプされます。
However, the secondary clamping is not performed for SPLITMV macroblocks, meaning that any subblock's motion vector within the SPLITMV macroblock may point outside the clamping zone. These non-clamped vectors are also used when determining the decoding tree context for subsequent subblocks' modes in the vp8_mvCont() function.
ただし、SplitMVマクロブロックではセカンダリクランプは実行されません。つまり、SplitMVマクロブロック内のサブブロックのモーションベクトルは、クランプゾーンの外側を指している可能性があります。これらの非クランプベクトルは、VP8_MVCONT（）関数の後続のサブブロックのモードのデコードツリーコンテキストを決定するときにも使用されます。
The prediction calculation for each subblock is then as follows. Temporarily disregarding the fractional part of the motion vector (that is, rounding "up" or "left" by right-shifting each component 3 bits with sign propagation) and adding the origin (upper left position) of the (16x16 luma or 8x8 chroma) current macroblock gives us an origin in the Y, U, or V plane of the predictor frame (either the golden frame or previous frame).
各サブブロックの予測計算は次のとおりです。モーションベクトルの分数部分を一時的に無視します（つまり、各コンポーネント3ビットを標識伝播で右シフトすることで「上」または「左」を丸めます）。）現在のマクロブロックは、予測因子フレームのy、u、またはV平面（ゴールデンフレームまたは以前のフレーム）の起源を提供します。
Considering that origin to be the upper left corner of a (luma or chroma) macroblock, we need to specify the relative positions of the pixels associated to that subblock, that is, any pixels that might be involved in the sub-pixel interpolation processes for the subblock.
その原点が（lumaまたはchroma）マクロブロックの左上隅であることを考慮すると、そのサブブロックに関連するピクセルの相対位置、つまりサブピクセル補間プロセスに関与する可能性のあるピクセルを指定する必要があります。サブブロック。
The sub-pixel interpolation is effected via two one-dimensional convolutions. These convolutions may be thought of as operating on a two-dimensional array of pixels whose origin is the subblock origin, that is the origin of the prediction macroblock described above plus the offset to the subblock. Because motion vectors are arbitrary, so are these "prediction subblock origins".
サブピクセルの補間は、2つの1次元畳み込みを介して行われます。これらの畳み込みは、原点がサブブロックの起源であるピクセルの2次元配列、つまり上記の予測マクロブロックの起源とサブブロックへのオフセットの起源で動作すると考えられるかもしれません。モーションベクトルは任意であるため、これらの「予測サブブロックの起源」も任意です。
The integer part of the motion vector is subsumed in the origin of the prediction subblock; the 16 (synthetic) pixels we need to construct are given by 16 offsets from the origin. The integer part of each of these offsets is the offset of the corresponding pixel from the subblock origin (using the vertical stride). To these integer parts is added a constant fractional part, which is simply the difference between the actual motion vector and its integer truncation used to calculate the origins of the prediction macroblock and subblock. Each component of this fractional part is an integer between 0 and 7, representing a forward displacement in eighths of a pixel.
モーションベクトルの整数部分は、予測サブブロックの原点に包まれています。構築する必要がある16（合成）ピクセルは、原点から16のオフセットによって与えられます。これらの各オフセットの整数部分は、サブブロック起点からの対応するピクセルのオフセットです（垂直ストライドを使用）。これらの整数部品に一定の分数部分が追加されます。これは、実際の動きベクトルと、予測マクロブロックとサブブロックの起源を計算するために使用される整数切り捨ての違いです。この分数部分の各コンポーネントは0〜7の間の整数であり、ピクセルの8分の1の前方変位を表します。
It is these fractional displacements that determine the filtering process. If they both happen to be zero (that is, we had a "whole pixel" motion vector), the prediction subblock is simply copied into the corresponding piece of the current macroblock's prediction buffer. As discussed in Section 14, the layout of the macroblock's prediction buffer can depend on the specifics of the reconstruction implementation chosen. Of course, the vertical displacement between lines of the prediction subblock is given by the stride, as are all vertical displacements used here.
フィルタリングプロセスを決定するのは、これらの部分的変位です。どちらもゼロ（つまり、「全体のピクセル」モーションベクトルがありました）である場合、予測サブブロックは、現在のマクロブロックの予測バッファーの対応する部分に単純にコピーされます。セクション14で説明したように、マクロブロックの予測バッファーのレイアウトは、選択した再構成実装の詳細に依存する可能性があります。もちろん、予測サブブロックの線間の垂直変位は、ここで使用されているすべての垂直変位と同様に、ストライドによって与えられます。
Otherwise, at least one of the fractional displacements is non-zero. We then synthesize the missing pixels via a horizontal, followed by a vertical, one-dimensional interpolation.
それ以外の場合、分数変位の少なくとも1つはゼロではありません。次に、水平を介して欠落しているピクセルを合成し、その後に垂直的で1次元補間を続けます。
The two interpolations are essentially identical. Each uses a (at most) six-tap filter (the choice of which of course depends on the one-dimensional offset). Thus, every calculated pixel references at most three pixels before (above or to the left of) it and at most three pixels after (below or to the right of) it. The horizontal interpolation must calculate two extra rows above and three extra rows below the 4x4 block, to provide enough samples for the vertical interpolation to proceed.
2つの補間は本質的に同一です。それぞれが（せいぜい）6タップフィルターを使用します（もちろん、1次元オフセットに依存する選択）。したがって、計算されたすべてのピクセル参照は、最大3ピクセル前（上または左の上または左側）で、最大3ピクセル後（下または右側）。水平方向の補間では、4x4ブロックの上に2つの余分な行と3つの追加行を計算して、垂直補間が進むのに十分なサンプルを提供する必要があります。
Depending on the reconstruction filter type given in the version number field in the frame tag, either a bicubic or a bilinear tap set is used.
フレームタグのバージョン番号フィールドで指定された再構成フィルタータイプに応じて、二頭筋または双線形タップセットのいずれかが使用されます。
The exact implementation of subsampling is as follows.
サブサンプリングの正確な実装は次のとおりです。
---- Begin code block --------------------------------------
/* Filter taps taken to 7-bit precision.
Because DC is always passed, taps always sum to 128. */
const int BilinearFilters[8][6] =
{
{ 0, 0, 128, 0, 0, 0 },
{ 0, 0, 112, 16, 0, 0 },
{ 0, 0, 96, 32, 0, 0 },
{ 0, 0, 80, 48, 0, 0 },
{ 0, 0, 64, 64, 0, 0 },
{ 0, 0, 48, 80, 0, 0 },
{ 0, 0, 32, 96, 0, 0 },
{ 0, 0, 16, 112, 0, 0 }
};
const int filters [8] [6] = { /* indexed by displacement */
{ 0, 0, 128, 0, 0, 0 }, /* degenerate whole-pixel */
{ 0, -6, 123, 12, -1, 0 }, /* 1/8 */
{ 2, -11, 108, 36, -8, 1 }, /* 1/4 */
{ 0, -9, 93, 50, -6, 0 }, /* 3/8 */
{ 3, -16, 77, 77, -16, 3 }, /* 1/2 is symmetric */
{ 0, -6, 50, 93, -9, 0 }, /* 5/8 = reverse of 3/8 */
{ 1, -8, 36, 108, -11, 2 }, /* 3/4 = reverse of 1/4 */
{ 0, -1, 12, 123, -6, 0 } /* 7/8 = reverse of 1/8 */
};
/* One-dimensional synthesis of a single sample.
Filter is determined by fractional displacement */
Pixel interp(
const int fil[6], /* filter to apply */
const Pixel *p, /* origin (rounded "before") in
prediction area */
const int s /* size of one forward step "" */
) {
int32 a = 0;
int i = 0;
p -= s + s; /* move back two positions */
do {
a += *p * fil[i];
p += s;
} while (++i < 6);
return clamp255((a + 64) >> 7); /* round to nearest
8-bit value */
}
/* First do horizontal interpolation, producing intermediate
buffer. */
void Hinterp(
Pixel temp[9][4], /* 9 rows of 4 (intermediate)
destination values */
const Pixel *p, /* subblock origin in prediction
frame */
int s, /* vertical stride to be used in
prediction frame */
uint hfrac, /* 0 <= horizontal displacement <= 7 */
uint bicubic /* 1=bicubic filter, 0=bilinear */
) {
const int * const fil = bicubic ? filters [hfrac] :
BilinearFilters[hfrac];
int r = 0; do /* for each row */
{
int c = 0; do /* for each destination sample */
{
/* Pixel separation = one horizontal step = 1 */
temp[r][c] = interp(fil, p + c, 1);
}
while (++c < 4);
}
while (p += s, ++r < 9); /* advance p to next row */
}
/* Finish with vertical interpolation, producing final results.
Input array "temp" is of course that computed above. */
void Vinterp(
Pixel final[4][4], /* 4 rows of 4 (final) destination values */
const Pixel temp[9][4],
uint vfrac, /* 0 <= vertical displacement <= 7 */
uint bicubic /* 1=bicubic filter, 0=bilinear */
) {
const int * const fil = bicubic ? filters [vfrac] :
BilinearFilters[vfrac];
int r = 0; do /* for each row */
{
int c = 0; do /* for each destination sample */
{
/* Pixel separation = one vertical step = width
of array = 4 */
final[r][c] = interp(fil, temp[r] + c, 4);
}
while (++c < 4);
}
while (++r < 4);
}
---- End code block ----------------------------------------
We discuss briefly the rationale behind the choice of filters. Our approach is necessarily cursory; a genuinely accurate discussion would require a couple of books. Readers unfamiliar with signal processing may or may not wish to skip this.
フィルターの選択の背後にある理論的根拠について簡単に説明します。私たちのアプローチは必然的に大まかです。本当に正確な議論には数冊の本が必要です。信号処理に不慣れな読者は、これをスキップしたい場合と望まない場合があります。
All digital signals are of course sampled in some fashion. The case where the inter-sample spacing (say in time for audio samples, or space for pixels) is uniform, that is, the same at all positions, is particularly common and amenable to analysis. Many aspects of the treatment of such signals are best-understood in the frequency domain via Fourier Analysis, particularly those aspects of the signal that are not changed by shifts in position, especially when those positional shifts are not given by a whole number of samples.
もちろん、すべてのデジタル信号は何らかの形でサンプリングされます。サンプル間間隔（オーディオサンプルに間に合うように、またはピクセルのスペースなど）が均一である場合、つまり、すべての位置で同じである場合、特に一般的で分析に適しています。そのようなシグナルの処理の多くの側面は、フーリエ分析、特に位置のシフトによって変更されない信号の側面、特にそれらの位置シフトが多数のサンプルによって与えられない場合、信号の側面に最もよく理解されています。
Non-integral translates of a sampled signal are a textbook example of the foregoing. In our case of non-integral motion vectors, we wish to say what the underlying image "really is" at these pixels; although we don't have values for them, we feel that it makes sense to talk about them. The correctness of this feeling is predicated on the underlying signal being band-limited, that is, not containing any energy in spatial frequencies that cannot be faithfully rendered at the pixel resolution at our disposal. In one dimension, this range of "OK" frequencies is called the Nyquist band; in our two-dimensional case of integer-grid samples, this range might be termed a Nyquist rectangle. The finer the grid, the more we know about the image, and the wider the Nyquist rectangle.
サンプリングされた信号の非統合翻訳は、前述の教科書の例です。非統合運動ベクトルの場合、これらのピクセルで根底にあるイメージが「本当に」ということを言いたいと思います。私たちは彼らの価値を持っていませんが、私たちは彼らについて話すのは理にかなっていると感じています。この感情の正しさは、基礎となる信号がバンド制限されていること、つまり、ピクセル解像度で忠実にレンダリングできない空間周波数にエネルギーを含めていないことに基づいています。1つの次元では、この「OK」周波数の範囲はナイキストバンドと呼ばれます。整数グリッドサンプルの2次元の場合、この範囲はナイキスト長方形と呼ばれる可能性があります。グリッドが細かくなればなるほど、画像について知り合い、ナイキストの長方形が広くなります。
It turns out that, for such band-limited signals, there is indeed an exact mathematical formula to produce the correct sample value at an arbitrary point. Unfortunately, this calculation requires the consideration of every single sample in the image, as well as needing to operate at infinite precision. Also, strictly speaking, all band-limited signals have infinite spatial (or temporal) extent, so everything we are discussing is really some sort of approximation.
このようなバンド制限された信号については、任意のポイントで正しいサンプル値を生成するための正確な数学的式が実際にあることがわかります。残念ながら、この計算には、画像内のすべてのサンプルを考慮し、無限の精度で動作する必要があります。また、厳密に言えば、すべてのバンド制限された信号には無限の空間的（または時間的）範囲があるため、私たちが議論しているものはすべて、何らかの近似です。
It is true that the theoretically correct subsampling procedure, as well as any approximation thereof, is always given by a translation-invariant weighted sum (or filter) similar to that used by VP8. It is also true that the reconstruction error made by such a filter can be simply represented as a multiplier in the frequency domain; that is, such filters simply multiply the Fourier transform of any signal to which they are applied by a fixed function associated to the filter. This fixed function is usually called the frequency response (or transfer function); the ideal subsampling filter has a frequency response equal to one in the Nyquist rectangle and zero everywhere else.
理論的に正しいサブサンプリング手順、およびその近似は、VP8が使用したものと同様の翻訳不変の加重和（またはフィルター）によって常に与えられることは事実です。また、このようなフィルターによって作成された再構成エラーが、周波数ドメインの乗数として単純に表現できることも事実です。つまり、そのようなフィルターは、フィルターに関連付けられた固定関数によって適用される信号のフーリエ変換を単純に掛けるだけです。この固定関数は通常、周波数応答（または転送関数）と呼ばれます。理想的なサブサンプリングフィルターには、ナイキストの長方形の1つに等しい周波数応答があり、他のどこでもゼロです。
Another basic fact about approximations to "truly correct" subsampling is that the wider the subrectangle (within the Nyquist rectangle) of spatial frequencies one wishes to "pass" (that is, correctly render) or, put more accurately, the closer one wishes to approximate the ideal transfer function, the more samples of the original signal must be considered by the subsampling, and the wider the calculation precision necessitated.
「真に正しい」サブサンプリングの近似に関する別の基本的な事実は、空間周波数のサブレクタング（ナイキストの長方形内）が「通過」したい（つまり、正しくレンダリング）、またはより正確に置くことを望むほど、より正確に配置することを望むということです。理想的な伝達関数に近いほど、サブサンプリングによって元の信号のサンプルをより多く考慮する必要があり、計算精度がより広く必要とする必要があります。
The filters chosen by VP8 were chosen, within the constraints of 4 or 6 taps and 7-bit precision, to do the best possible job of handling the low spatial frequencies near the 0th DC frequency along with introducing no resonances (places where the absolute value of the frequency response exceeds one).
VP8によって選択されたフィルターは、4または6タップと7ビット精度の制約内で選択され、0番目のDC周波数の近くで低空間周波数を処理するための最良の仕事を行うことと、共鳴なし（絶対値がある場所の場所）周波数応答の1を超えます）。
The justification for the foregoing has two parts. First, resonances can produce extremely objectionable visible artifacts when, as often happens in actual compressed video streams, filters are applied repeatedly. Second, the vast majority of energy in real-world images lies near DC and not at the high end.
前述の正当化には2つの部分があります。第一に、共鳴は、実際の圧縮ビデオストリームで頻繁に発生するように、フィルターが繰り返し塗布されると、非常に好ましくない可視アーティファクトを生成する可能性があります。第二に、実際の画像のエネルギーの大部分はDCの近くにあり、ハイエンドではありません。
To get slightly more specific, the filters chosen by VP8 are the best resonance-free 4- or 6-tap filters possible, where "best" describes the frequency response near the origin: The response at 0 is required to be 1, and the graph of the response at 0 is as flat as possible.
わずかに具体的に取得するために、VP8によって選択されたフィルターは、可能な限り最高の共鳴フリー4または6タップフィルターです。ここで、「最適」は原点近くの周波数応答を記述します。0での応答は1であり、0での応答のグラフは、できるだけフラットです。
To provide an intuitively more obvious point of reference, the "best" 2-tap filter is given by simple linear interpolation between the surrounding actual pixels.
直感的により明白な参照ポイントを提供するために、「最良の」2タップフィルターは、周囲の実際のピクセル間の単純な線形補間によって与えられます。
Finally, it should be noted that, because of the way motion vectors are calculated, the (shorter) 4-tap filters (used for odd fractional displacements) are applied in the chroma plane only. Human color perception is notoriously poor, especially where higher spatial frequencies are involved. The shorter filters are easier to understand mathematically, and the difference between them and a theoretically slightly better 6-tap filter is negligible where chroma is concerned.
最後に、モーションベクトルの計算方法のために、（より短い）4タップフィルター（奇数分数変位に使用）がクロマ平面にのみ適用されることに注意してください。人間の色の知覚は、特により高い空間周波数が関与している場合、悪名高いことで有名です。短いフィルターは数学的に理解しやすく、それらと理論的にわずかに優れた6タップフィルターの違いは、Chromaが関係する場合は無視できます。
This annex presents the bitstream syntax in a tabular form. All the information elements have been introduced and explained in the previous sections but are collected here for a quick reference. Each syntax element is briefly described after the tabular representation along with a reference to the corresponding paragraph in the main document. The meaning of each syntax element value is not repeated here.
この付属書は、BitStreamの構文を表形式の構文を示します。すべての情報要素は、前のセクションで導入および説明されていますが、ここでは迅速な参照のために収集されます。各構文要素は、主なドキュメントの対応する段落への参照とともに、表形式の表現の後に簡単に説明されています。各構文要素値の意味は、ここでは繰り返されません。
The top-level hierarchy of the bitstream is introduced in Section 4.
ビットストリームのトップレベルの階層は、セクション4で紹介されています。
Definition of syntax element coding types can be found in Section 8. The types used in the representation in this annex are:
構文要素コーディングタイプの定義は、セクション8にあります。この付録の表現で使用されるタイプは次のとおりです。
o f(n), n-bit value from stream (n successive bits, not boolean encoded)
o f（n）、ストリームからのnビット値（n連続したビット、ブールエンコードされていない）
o L(n), n-bit number encoded as n booleans (with equal probability of being 0 or 1)
o l（n）、n buleansとしてエンコードされたnビット数（0または1である可能性が等しい）
o B(p), bool with probability p of being 0
o b（p）、0の確率pを持つブール
o T, tree-encoded value
o t、ツリーエンコード値
| Frame Tag | Type |
| ------------------------------------------------- | ----- |
| frame_tag | f(24) |
| if (key_frame) { | |
| start_code | f(24) |
| horizontal_size_code | f(16) |
| vertical_size_code | f(16) |
| } | |
The 3-byte frame tag can be parsed as follows:
3バイトのフレームタグは、次のように解析できます。
---- Begin code block --------------------------------------
unsigned char *c = pbi->source;
unsigned int tmp;
tmp = (c[2] << 16) | (c[1] << 8) | c[0];
key_frame = tmp & 0x1;
version = (tmp >> 1) & 0x7;
show_frame = (tmp >> 4) & 0x1;
first_part_size = (tmp >> 5) & 0x7FFFF;
---- End code block ----------------------------------------
Where:
ただし：
o key_frame indicates whether the current frame is a key frame or not.
o key_frameは、現在のフレームがキーフレームであるかどうかを示します。
o version determines the bitstream version.
o バージョンは、BitStreamバージョンを決定します。
o show_frame indicates whether the current frame is meant to be displayed or not.
o show_frameは、現在のフレームが表示されるかどうかを示します。
o first_part_size determines the size of the first partition (control partition), excluding the uncompressed data chunk.
o first_part_size最初のパーティション（制御パーティション）のサイズを決定し、非圧縮データチャンクを除く。
The start_code is a constant 3-byte pattern having value 0x9d012a. The latter part of the uncompressed chunk (after the start_code) can be parsed as follows:
start_codeは、値0x9d012aを持つ一定の3バイトパターンです。非圧縮チャンクの後半（start_codeの後）は次のように解析できます。
---- Begin code block --------------------------------------
unsigned char *c = pbi->source + 6;
unsigned int tmp;
tmp = (c[1] << 8) | c[0];
width = tmp & 0x3FFF;
horizontal_scale = tmp >> 14;
tmp = (c[3] << 8) | c[2];
height = tmp & 0x3FFF;
vertical_scale = tmp >> 14;
---- End code block ----------------------------------------
| Frame Header | Type |
| ------------------------------------------------- | ----- |
| if (key_frame) { | |
| color_space | L(1) |
| clamping_type | L(1) |
| } | |
| segmentation_enabled | L(1) |
| if (segmentation_enabled) | |
| update_segmentation() | |
| filter_type | L(1) |
| loop_filter_level | L(6) |
| sharpness_level | L(3) |
| mb_lf_adjustments() | |
| log2_nbr_of_dct_partitions | L(2) |
| quant_indices() | |
| if (key_frame) | |
| refresh_entropy_probs | L(1) |
| else { | |
| refresh_golden_frame | L(1) |
| refresh_alternate_frame | L(1) |
| if (!refresh_golden_frame) | |
| copy_buffer_to_golden | L(2) |
| if (!refresh_alternate_frame) | |
| copy_buffer_to_alternate | L(2) |
| sign_bias_golden | L(1) |
| sign_bias_alternate | L(1) |
| refresh_entropy_probs | L(1) |
| refresh_last | L(1) |
| } | |
| token_prob_update() | |
| mb_no_skip_coeff | L(1) |
| if (mb_no_skip_coeff) | |
| prob_skip_false | L(8) |
| if (!key_frame) { | |
| prob_intra | L(8) |
| prob_last | L(8) |
| prob_gf | L(8) |
| intra_16x16_prob_update_flag | L(1) |
| if (intra_16x16_prob_update_flag) { | |
| for (i = 0; i < 4; i++) | |
| intra_16x16_prob | L(8) |
| } | |
| intra_chroma prob_update_flag | L(1) |
| if (intra_chroma_prob_update_flag) { | |
| for (i = 0; i < 3; i++) | |
| intra_chroma_prob | L(8) |
| } | |
| mv_prob_update() | |
| } | |
o color_space defines the YUV color space of the sequence (Section 9.2)
o Color_spaceは、シーケンスのYUVカラー空間を定義します（セクション9.2）
o clamping_type specifies if the decoder is required to clamp the reconstructed pixel values (Section 9.2)
o clamping_type再構成されたピクセル値をクランプするためにデコーダーが必要な場合（セクション9.2）
o segmentation_enabled enables the segmentation feature for the current frame (Section 9.3)
o segmentation_enabled現在のフレームのセグメンテーション機能を有効にします（セクション9.3）
o filter_type determines whether the normal or the simple loop filter is used (Sections 9.4, 15)
o filter_typeは、通常のループフィルターか単純なループフィルターが使用されるかどうかを決定します（セクション9.4、15）
o loop_filter_level controls the deblocking filter (Sections 9.4, 15)
o loop_filter_levelはデブロッキングフィルターを制御します（セクション9.4、15）
o sharpness_level controls the deblocking filter (Sections 9.4, 15)
o Sharpness_Levelはデブロッキングフィルターを制御します（セクション9.4、15）
o log2_nbr_of_dct_partitions determines the number of separate partitions containing the DCT coefficients of the macroblocks (Section 9.5)
o log2_nbr_of_of_dct_partitionsマクロブロックのDCT係数を含む個別のパーティションの数を決定します（セクション9.5）
o refresh_entropy_probs determines whether updated token probabilities are used only for this frame or until further update
o refresh_entropy_probsは、更新されたトークン確率がこのフレームにのみ使用されるのか、さらに更新されるまで使用されるかどうかを決定します
o refresh_golden_frame determines if the current decoded frame refreshes the golden frame (Section 9.7)
o refresh_golden_frameの現在のデコードされたフレームがゴールデンフレームを再表示するかどうかを決定します（セクション9.7）
o refresh_alternate_frame determines if the current decoded frame refreshes the alternate reference frame (Section 9.7)
o refresh_alternate_frameの現在のデコードされたフレームが代替参照フレームを再表示するかどうかを決定します（セクション9.7）
o copy_buffer_to_golden determines if the golden reference is replaced by another reference (Section 9.7)
o copy_buffer_to_goldenは、ゴールデン参照が別の参照に置き換えられているかどうかを決定します（セクション9.7）
o copy_buffer_to_alternate determines if the alternate reference is replaced by another reference (Section 9.7)
o copy_buffer_to_alternateは、代替参照が別の参照に置き換えられているかどうかを決定します（セクション9.7）
o sign_bias_golden controls the sign of motion vectors when the golden frame is referenced (Section 9.7)
o sign_bias_goldenゴールデンフレームが参照されるときにモーションベクトルの符号を制御します（セクション9.7）
o sign_bias_alternate controls the sign of motion vectors when the alternate frame is referenced (Section 9.7)
o sign_bias_alternate代替フレームが参照されている場合、モーションベクトルの符号を制御します（セクション9.7）
o refresh_last determines if the current decoded frame refreshes the last frame reference buffer (Section 9.8)
o refresh_last電流デコードされたフレームが最後のフレーム参照バッファーを再表示するかどうかを判断します（セクション9.8）
o mb_no_skip_coeff enables or disables the skipping of macroblocks containing no non-zero coefficients (Section 9.10)
o MB_NO_SKIP_COEFFは、ゼロ以外の係数を含むマクロブロックのスキップを有効または無効にします（セクション9.10）
o prob_skip_false indicates the probability that the macroblock is not skipped (flag indicating skipped macroblock is false) (Section 9.10)
o prob_skip_falseは、マクロブロックがスキップされない確率を示します（スキップされたマクロブロックが偽であることを示すフラグ）（セクション9.10）
o prob_intra indicates the probability of an intra macroblock (Section 9.10)
o prob_intraは、マクロブロック内の確率を示します（セクション9.10）
o prob_last indicates the probability that the last reference frame is used for inter-prediction (Section 9.10)
o prob_lastは、最後の参照フレームが予測間で使用される確率を示します（セクション9.10）
o prob_gf indicates the probability that the golden reference frame is used for inter-prediction (Section 9.10)
o prob_gfは、ゴールデン参照フレームが予測間で使用される確率を示します（セクション9.10）
o intra_16x16_prob_update_flag indicates if the branch probabilities used in the decoding of the luma intra-prediction mode are updated (Section 9.10)
o intra_16x16_prob_update_flagは、ルーマ内予測モードのデコードで使用されるブランチ確率が更新されているかどうかを示します（セクション9.10）
o intra_16x16_prob indicates the branch probabilities of the luma intra-prediction mode decoding tree
o intra_16x16_probは、LUMAの予測モードデコードツリーのブランチ確率を示します
o intra_chroma_prob_update_flag indicates if the branch probabilities used in the decoding of the chroma intra-prediction mode are updated (Section 9.10)
o intra_chroma_prob_update_flagは、クロマの予測モードのデコードで使用されるブランチ確率が更新されているかどうかを示します（セクション9.10）
o intra_chroma_prob indicates the branch probabilities of the chroma intra-prediction mode decoding tree
o intra_chroma_probは、クロマの予測モードデコードツリーのブランチ確率を示します
| update_segmentation() | Type |
| ------------------------------------------------- | ----- |
| update_mb_segmentation_map | L(1) |
| update_segment_feature_data | L(1) |
| if (update_segment_feature_data) { | |
| segment_feature_mode | L(1) |
| for (i = 0; i < 4; i++) { | |
| quantizer_update | L(1) |
| if (quantizer_update) { | |
| quantizer_update_value | L(7) |
| quantizer_update_sign | L(1) |
| } | |
| } | |
| for (i = 0; i < 4; i++) { | |
| loop_filter_update | L(1) |
| if (loop_filter_update) { | |
| lf_update_value | L(6) |
| lf_update_sign | L(1) |
| } | |
| } | |
| } | |
| if (update_mb_segmentation_map) { | |
| for (i = 0; i < 3; i++) { | |
| segment_prob_update | L(1) |
| if (segment_prob_update) | |
| segment_prob | L(8) |
| } | |
| } | |
o update_mb_segmentation_map determines if the MB segmentation map is updated in the current frame (Section 9.3)
o update_mb_segmentation_mapは、MBセグメンテーションマップが現在のフレームで更新されているかどうかを決定します（セクション9.3）
o update_segment_feature_data indicates if the segment feature data is updated in the current frame (Section 9.3)
o update_segment_feature_dataは、セグメント機能データが現在のフレームで更新されているかどうかを示します（セクション9.3）
o segment_feature_mode indicates the feature data update mode, 0 for delta and 1 for the absolute value (Section 9.3)
o segment_feature_mode機能データの更新モード、デルタの場合は0、絶対値の場合は1を示します（セクション9.3）
o quantizer_update indicates if the quantizer value is updated for the i^(th) segment (Section 9.3)
o Quantizer_Updateは、i^（th）セグメントの量子化値が更新されているかどうかを示します（セクション9.3）
o quantizer_update_value indicates the update value for the segment quantizer (Section 9.3)
o Quantizer_update_Valueは、セグメントの量子化器の更新値を示します（セクション9.3）
o quantizer_update_sign indicates the update sign for the segment quantizer (Section 9.3)
o Quantizer_update_Signセグメント量子化器の更新サインを示します（セクション9.3）
o loop_filter_update indicates if the loop filter level value is updated for the i^(th) segment (Section 9.3)
o loop_filter_updateは、i^（th）セグメントのループフィルターレベル値が更新されているかどうかを示します（セクション9.3）
o lf_update_value indicates the update value for the loop filter level (Section 9.3)
o lf_update_valueは、ループフィルターレベルの更新値を示します（セクション9.3）
o lf_update_sign indicates the update sign for the loop filter level (Section 9.3)
o lf_update_signループフィルターレベルの更新符号を示します（セクション9.3）
o segment_prob_update indicates whether the branch probabilities used to decode the segment_id in the MB header are decoded from the stream or use the default value of 255 (Section 9.3)
o segment_prob_update MBヘッダーのsegment_idをデコードするために使用されるブランチ確率がストリームからデコードされるか、デフォルト値255（セクション9.3）を使用しているかどうかを示します。
o segment_prob indicates the branch probabilities of the segment_id decoding tree (Section 9.3)
o segment_probは、segment_idデコードツリーの分岐確率を示します（セクション9.3）
| mb_lf_adjustments() | Type |
| ------------------------------------------------- | ----- |
| loop_filter_adj_enable | L(1) |
| if (loop_filter_adj_enable) { | |
| mode_ref_lf_delta_update | L(1) |
| if (mode_ref_lf_delta_update) { | |
| for (i = 0; i < 4; i++) { | |
| ref_frame_delta_update_flag | L(1) |
| if (ref_frame_delta_update_flag) { | |
| delta_magnitude | L(6) |
| delta_sign | L(1) |
| } | |
| } | |
| for (i = 0; i < 4; i++) { | |
| mb_mode_delta_update_flag | L(1) |
| if (mb_mode_delta_update_flag) { | |
| delta_magnitude | L(6) |
| delta_sign | L(1) |
| } | |
| } | |
| } | |
| } | |
o loop_filter_adj_enable indicates if the MB-level loop filter adjustment (based on the used reference frame and coding mode) is on for the current frame (Section 9.4)
o LOOP_FILTER_ADJ_ENABLEは、現在のフレーム（セクション9.4）に対して、MBレベルループフィルター調整（使用されている参照フレームとコーディングモードに基づく）がオンになっているかどうかを示します。
o mode_ref_lf_delta_update indicates if the delta values used in an adjustment are updated in the current frame (Section 9.4)
o MODE_REF_LF_DELTA_UPDATEは、調整で使用されているデルタ値が現在のフレームで更新されているかどうかを示します（セクション9.4）
o ref_frame_delta_update_flag indicates if the adjustment delta value corresponding to a certain used reference frame is updated (Section 9.4)
o ref_frame_delta_update_flagは、特定の使用されている参照フレームに対応する調整デルタ値が更新されているかどうかを示します（セクション9.4）
o delta_magnitude is the absolute value of the delta value
o Delta_magnitudeは、Delta値の絶対値です
o delta_sign is the sign of the delta value
o Delta_SignはDelta値の兆候です
o mb_mode_delta_update_flag indicates if the adjustment delta value corresponding to a certain MB prediction mode is updated (Section 9.4)
o MB_MODE_DELTA_UPDATE_FLAGは、特定のMB予測モードに対応する調整デルタ値が更新されているかどうかを示します（セクション9.4）
| quant_indices() | Type |
| ------------------------------------------------- | ----- |
| y_ac_qi | L(7) |
| y_dc_delta_present | L(1) |
| if (y_dc_delta_present) { | |
| y_dc_delta_magnitude | L(4) |
| y_dc_delta_sign | L(1) |
| } | |
| y2_dc_delta_present | L(1) |
| if (y2_dc_delta_present) { | |
| y2_dc_delta_magnitude | L(4) |
| y2_dc_delta_sign | L(1) |
| } | |
| y2_ac_delta_present | L(1) |
| if (y2_ac_delta_present) { | |
| y2_ac_delta_magnitude | L(4) |
| y2_ac_delta_sign | L(1) |
| } | |
| uv_dc_delta_present | L(1) |
| if (uv_dc_delta_present) { | |
| uv_dc_delta_magnitude | L(4) |
| uv_dc_delta_sign | L(1) |
| } | |
| uv_ac_delta_present | L(1) |
| if (uv_ac_delta_present) { | |
| uv_ac_delta_magnitude | L(4) |
| uv_ac_delta_sign | L(1) |
| } | |
o y_ac_qi is the dequantization table index used for the luma AC coefficients (and other coefficient groups if no delta value is present) (Section 9.6)
o Y_AC_QIは、LUMA AC係数（およびデルタ値が存在しない場合、その他の係数グループ）に使用される不安定化テーブルインデックスです（セクション9.6）
o y_dc_delta_present indicates if the stream contains a delta value that is added to the baseline index to obtain the luma DC coefficient dequantization index (Section 9.6)
o Y_DC_DELTA_PRESENTストリームにベースラインインデックスに追加されるデルタ値が含まれているかどうかを示して、LUMA DC係数脱量化インデックス（セクション9.6）を取得します
o y_dc_delta_magnitude is the magnitude of the delta value (Section 9.6)
o y_dc_delta_magnitudeはデルタ値の大きさです（セクション9.6）
o y_dc_delta_sign is the sign of the delta value (Section 9.6)
o y_dc_delta_signはデルタ値の兆候です（セクション9.6）
o y2_dc_delta_present indicates if the stream contains a delta value that is added to the baseline index to obtain the Y2 block DC coefficient dequantization index (Section 9.6)
o Y2_DC_DELTA_PRESENTストリームにベースラインインデックスに追加されるデルタ値が含まれているかどうかを示して、Y2ブロックDC係数デコンゼーションインデックス（セクション9.6）を取得します
o y2_ac_delta_present indicates if the stream contains a delta value that is added to the baseline index to obtain the Y2 block AC coefficient dequantization index (Section 9.6)
o Y2_AC_DELTA_PRESENTストリームにベースラインインデックスに追加されるデルタ値が含まれているかどうかを示して、Y2ブロックAC係数デコンティ化インデックス（セクション9.6）を取得します
o uv_dc_delta_present indicates if the stream contains a delta value that is added to the baseline index to obtain the chroma DC coefficient dequantization index (Section 9.6)
o UV_DC_DELTA_PRESENTストリームにベースラインインデックスに追加されるデルタ値が含まれているかどうかを示して、Chroma DC係数デコンティゼーションインデックス（セクション9.6）を取得します
o uv_ac_delta_present indicates if the stream contains a delta value that is added to the baseline index to obtain the chroma AC coefficient dequantization index (Section 9.6)
o UV_AC_DELTA_PRESENTストリームにベースラインインデックスに追加されるデルタ値が含まれているかどうかを示して、Chroma AC係数デコンティ化インデックス（セクション9.6）を取得します
| token_prob_update() | Type |
| ------------------------------------------------- | ----- |
| for (i = 0; i < 4; i++) { | |
| for (j = 0; j < 8; j++) { | |
| for (k = 0; k < 3; k++) { | |
| for (l = 0; l < 11; l++) { | |
| coeff_prob_update_flag | L(1) |
| if (coeff_prob_update_flag) | |
| coeff_prob | L(8) |
| } | |
| } | |
| } | |
| } | |
o coeff_prob_update_flag indicates if the corresponding branch probability is updated in the current frame (Section 13.4)
o coeff_prob_update_flagは、対応するブランチの確率が現在のフレームで更新されているかどうかを示します（セクション13.4）
o coeff_prob is the new branch probability (Section 13.4)
o coeff_probは新しいブランチの確率です（セクション13.4）
| mv_prob_update() | Type |
| ------------------------------------------------- | ----- |
| for (i = 0; i < 2; i++) { | |
| for (j = 0; j < 19; j++) { | |
| mv_prob_update_flag | L(1) |
| if (mv_prob_update_flag) | |
| prob | L(7) |
| } | |
| } | |
o mv_prob_update_flag indicates if the corresponding MV decoding probability is updated in the current frame (Section 17.2)
o MV_PROB_UPDATE_FLAGは、対応するMVデコード確率が現在のフレームで更新されているかどうかを示します（セクション17.2）
o prob is the updated probability (Section 17.2)
o probは更新された確率（セクション17.2）です
| Macroblock Data | Type |
| ------------------------------------------------- | ----- |
| macroblock_header() | |
| residual_data() | |
| macroblock_header() | Type |
| ------------------------------------------------- | ----- |
| if (update_mb_segmentation_map) | |
| segment_id | T |
| if (mb_no_skip_coeff) | |
| mb_skip_coeff | B(p) |
| if (!key_frame) | |
| is_inter_mb | B(p) |
| if (is_inter_mb) { | |
| mb_ref_frame_sel1 | B(p) |
| if (mb_ref_frame_sel1) | |
| mb_ref_frame_sel2 | B(p) |
| mv_mode | T |
| if (mv_mode == SPLITMV) { | |
| mv_split_mode | T |
| for (i = 0; i < numMvs; i++) { | |
| sub_mv_mode | T |
| if (sub_mv_mode == NEWMV4x4) { | |
| read_mvcomponent() | |
| read_mvcomponent() | |
| } | |
| } | |
| } else if (mv_mode == NEWMV) { | |
| read_mvcomponent() | |
| read_mvcomponent() | |
| } | |
| } else { /* intra mb */ | |
| intra_y_mode | T |
| if (intra_y_mode == B_PRED) { | |
| for (i = 0; i < 16; i++) | |
| intra_b_mode | T |
| } | |
| intra_uv_mode | T |
| } | |
o segment_id indicates to which segment the macroblock belongs (Section 10)
o segment_idは、マクロブロックがどのセグメントに属しているかを示します（セクション10）
o mb_skip_coeff indicates whether the macroblock contains any coded coefficients or not (Section 11.1)
o MB_SKIP_COEFFは、マクロブロックにコード化された係数が含まれているかどうかを示します（セクション11.1）
o is_inter_mb indicates whether the macroblock is intra- or inter-coded (Section 16)
o IS_INTER_MBは、マクロブロックがイントラコードまたはインターコード化されているかどうかを示します（セクション16）
o mb_ref_frame_sel1 selects the reference frame to be used; last frame (0), golden/alternate (1) (Section 16.2)
o MB_REF_FRAME_SEL1使用する参照フレームを選択します。最後のフレーム（0）、ゴールデン/代替（1）（セクション16.2）
o mb_ref_frame_sel2 selects whether the golden (0) or alternate reference frame (1) is used (Section 16.2)
o MB_REF_FRAME_SEL2ゴールデン（0）または代替参照フレーム（1）が使用されるかどうかを選択します（セクション16.2）
o mv_mode determines the macroblock motion vector mode (Section 16.2)
o MV_MODEマクロブロックモーションベクトルモード（セクション16.2）を決定します
o mv_split_mode gives the macroblock partitioning specification and determines the number of motion vectors used (numMvs) (Section 16.2)
o MV_SPLIT_MODEはマクロブロックパーティション仕様を提供し、使用するモーションベクトルの数（NUMMVS）の数を決定します（セクション16.2）
o sub_mv_mode determines the sub-macroblock motion vector mode for macroblocks coded using the SPLITMV motion vector mode (Section 16.2)
o sub_mv_mode splitMVモーションベクトルモード（セクション16.2）を使用してコード化されたマクロブロックのサブマクロブロックモーションベクトルモードを決定します
o intra_y_mode selects the luminance intra-prediction mode (Section 16.1)
o intra_y_mode輝度イントラ予測モード（セクション16.1）を選択します
o intra_b_mode selects the sub-macroblock luminance prediction mode for macroblocks coded using B_PRED mode (Section 16.1)
o intra_b_mode b_predモードを使用してコード化されたマクロブロックのサブマクロブロック輝度予測モードを選択します（セクション16.1）
o intra_uv_mode selects the chrominance intra-prediction mode (Section 16.1)
o intra_uv_modeクロミナンス内容モードを選択します（セクション16.1）
| residual_data() | Type |
| ------------------------------------------------- | ----- |
| if (!mb_skip_coeff) { | |
| if ( (is_inter_mb && mv_mode != SPLITMV) || | |
| (!is_inter_mb && intra_y_mode != B_PRED) ) | |
| residual_block() /* Y2 */ | |
| for (i = 0; i < 24; i++) | |
| residual_block() /* 16 Y, 4 U, 4 V */ | |
| } | |
| residual_block() | Type |
| ------------------------------------------------- | ----- |
| for (i = firstCoeff; i < 16; i++) { | |
| token | T |
| if (token == EOB) break; | |
| if (token_has_extra_bits) | |
| extra_bits | L(n) |
| if (coefficient != 0) | |
| sign | L(1) |
| } | |
o firstCoeff is 1 for luma blocks of macroblocks containing Y2 subblock; otherwise 0
o FirstCoeffは、Y2サブブロックを含むマクロブロックのLUMAブロックの1です。それ以外の場合は0
o token defines the value of the coefficient, the value range of the coefficient, or the end of block (Section 13.2)
o トークンは、係数の値、係数の値範囲、またはブロックの終わりを定義します（セクション13.2）
o extra_bits determines the value of the coefficient within the value range defined by the token (Section 13.2)
o Extra_bitsは、トークンで定義された値範囲内の係数の値を決定します（セクション13.2）
o sign indicates the sign of the coefficient (Section 13.2)
o 記号は係数の符号を示します（セクション13.2）
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef BIT_OPS_H
#define BIT_OPS_H
/* Evaluates to a mask with n bits set */
#define BITS_MASK(n) ((1<<(n))-1)
/* Returns len bits, with the LSB at position bit */
#define BITS_GET(val, bit, len) (((val)>>(bit))&BITS_MASK(len))
#endif
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef BOOL_DECODER_H
#define BOOL_DECODER_H
#include <stddef.h>
struct bool_decoder
{
const unsigned char *input; /* next compressed data byte */
size_t input_len; /* length of the input buffer */
unsigned int range; /* identical to encoder's
* range */
unsigned int value; /* contains at least 8
* significant bits */
int bit_count; /* # of bits shifted out of
* value, max 7 */
};
static void
init_bool_decoder(struct bool_decoder *d,
const unsigned char *start_partition,
size_t sz)
{
if (sz >= 2)
{
d->value = (start_partition[0] << 8) /* first 2 input
* bytes */
| start_partition[1];
d->input = start_partition + 2; /* ptr to next byte */
d->input_len = sz - 2;
}
else
{
d->value = 0;
d->input = NULL;
d->input_len = 0;
}
d->range = 255; /* initial range is full */
d->bit_count = 0; /* have not yet shifted out any bits */
}
static int bool_get(struct bool_decoder *d, int probability)
{
/* range and split are identical to the corresponding values
used by the encoder when this bool was written */
unsigned int split = 1 + (((d->range - 1) * probability) >> 8);
unsigned int SPLIT = split << 8;
int retval; /* will be 0 or 1 */
if (d->value >= SPLIT) /* encoded a one */
{
retval = 1;
d->range -= split; /* reduce range */
d->value -= SPLIT; /* subtract off left endpoint of
* interval */
}
else /* encoded a zero */
{
retval = 0;
d->range = split; /* reduce range, no change in left
* endpoint */
}
while (d->range < 128) /* shift out irrelevant value bits */
{
d->value <<= 1;
d->range <<= 1;
if (++d->bit_count == 8) /* shift in new bits 8 at a time */
{
d->bit_count = 0;
if (d->input_len)
{
d->value |= *d->input++;
d->input_len--;
}
}
}
return retval; }
返品retval;}
static int bool_get_bit(struct bool_decoder *br)
{
return bool_get(br, 128);
}
static int bool_get_uint(struct bool_decoder *br, int bits)
{
int z = 0;
int bit;
for (bit = bits - 1; bit >= 0; bit--)
{
z |= (bool_get_bit(br) << bit);
}
return z; }
zを返します。}
static int bool_get_int(struct bool_decoder *br, int bits)
{
int z = 0;
int bit;
for (bit = bits - 1; bit >= 0; bit--)
{
z |= (bool_get_bit(br) << bit);
}
return bool_get_bit(br) ? -z : z;
}
static int bool_maybe_get_int(struct bool_decoder *br, int bits)
{
return bool_get_bit(br) ? bool_get_int(br, bits) : 0;
}
static int bool_read_tree(struct bool_decoder *bool, const int *t, const unsigned char *p) { int i = 0;
static int bool_read_tree（struct bool_decoder *bool、const int *t、const unsigned char *p）{int i = 0;
while ((i = t[ i + bool_get(bool, p[i>>1])]) > 0);
return -i; } #endif
return -i;} #endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
static const int dc_q_lookup[128] = { 4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17, 18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 91, 93, 95, 96, 98, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 143, 145, 148, 151, 154, 157 };
static const int dc_q_lookup [128] = {4、5、6、7、8、9、10、11、12、13、14、15、16、17、17、18、19、20、20、21、21、22、22、23、23、24、25、25、26、27、28、29、30、31、32、33、34、35、36、37、37、38、39、40、41、42、43、44、45、46、46、47、48、49、50、51、52、53、54、55、56、57、58、59、60、61、62、63、64、64、65、66、67、68、69、70、71、72、73、74、75、76、76、77、78、79、80、81、82、83、84、85、86、87、87、88、89、91、93、95、96、98、100、101、102、104、106、108、110、112、114、116、118、122、124、126、128、130、132、134、136、138、140、143、145、148、151、154、157};
static const int ac_q_lookup[128] = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 119, 122, 125, 128, 131, 134, 137, 140, 143, 146, 149, 152,
static const int ac_q_lookup [128] = {4、5、6、7、8、9、10、11、12、13、14、16、17、18、19、20、21、22、23、24、25、26、27、28、29、30、31、32、33、34、35、36、37、38、39、40、41、42、43、44、45、46、47、48、49、50、51、52、53、54、55、56、57、58、60、62、64、66、68、70、72、74、76、78、80、82、84、86、88、90、92、94、96、98、100、102、104、106、108、110、112、114、116、119、122、125、128、131、134、137、140、143、146、149、152、149、152、
155, 158, 161, 164, 167, 170, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 234, 239, 245, 249, 254, 259, 264, 269, 274, 279, 284 };
155、158、161、164、167、170、173、177、181、185、189、193、197、201、205、209、213、217、221、225、229、234、239、245、245、249、249、254、259、264、269、274、279、284};
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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_codec_internal.h"
#include "bit_ops.h"
#include "dixie.h"
#include "vp8_prob_data.h"
#include "dequant_data.h"
#include "modemv.h"
#include "tokens.h"
#include "predict.h"
#include "dixie_loopfilter.h"
#include <string.h>
#include <assert.h>
enum { FRAME_HEADER_SZ = 3, KEYFRAME_HEADER_SZ = 7 };
enum {frame_header_sz = 3、keyframe_header_sz = 7};
#define ARRAY_COPY(a,b) {\
assert(sizeof(a)==sizeof(b));memcpy(a,b,sizeof(a));}
static void
decode_entropy_header(struct vp8_decoder_ctx *ctx,
struct bool_decoder *bool,
struct vp8_entropy_hdr *hdr)
{ int i, j, k, l;
{int i、j、k、l;
/* Read coefficient probability updates */
for (i = 0; i < BLOCK_TYPES; i++)
for (j = 0; j < COEFF_BANDS; j++)
for (k = 0; k < PREV_COEFF_CONTEXTS; k++)
for (l = 0; l < ENTROPY_NODES; l++)
if (bool_get(bool,
k_coeff_entropy_update_probs
[i][j][k][l]))
hdr->coeff_probs[i][j][k][l] =
bool_get_uint(bool, 8);
/* Read coefficient skip mode probability */
hdr->coeff_skip_enabled = bool_get_bit(bool);
if (hdr->coeff_skip_enabled)
hdr->coeff_skip_prob = bool_get_uint(bool, 8);
/* Parse interframe probability updates */
if (!ctx->frame_hdr.is_keyframe)
{
hdr->prob_inter = bool_get_uint(bool, 8);
hdr->prob_last = bool_get_uint(bool, 8);
hdr->prob_gf = bool_get_uint(bool, 8);
if (bool_get_bit(bool))
for (i = 0; i < 4; i++)
hdr->y_mode_probs[i] = bool_get_uint(bool, 8);
if (bool_get_bit(bool))
for (i = 0; i < 3; i++)
hdr->uv_mode_probs[i] = bool_get_uint(bool, 8);
for (i = 0; i < 2; i++)
for (j = 0; j < MV_PROB_CNT; j++)
if (bool_get(bool, k_mv_entropy_update_probs[i][j]))
{
int x = bool_get_uint(bool, 7);
hdr->mv_probs[i][j] = x ? x << 1 : 1;
}
}
}
static void
decode_reference_header(struct vp8_decoder_ctx *ctx,
struct bool_decoder *bool,
struct vp8_reference_hdr *hdr)
{
unsigned int key = ctx->frame_hdr.is_keyframe;
hdr->refresh_gf = key ? 1 : bool_get_bit(bool);
hdr->refresh_arf = key ? 1 : bool_get_bit(bool);
hdr->copy_gf = key ? 0 : !hdr->refresh_gf
? bool_get_uint(bool, 2) : 0;
hdr->copy_arf = key ? 0 : !hdr->refresh_arf
? bool_get_uint(bool, 2) : 0;
hdr->sign_bias[GOLDEN_FRAME] = key ? 0 : bool_get_bit(bool);
hdr->sign_bias[ALTREF_FRAME] = key ? 0 : bool_get_bit(bool);
hdr->refresh_entropy = bool_get_bit(bool);
hdr->refresh_last = key ? 1 : bool_get_bit(bool);
}
static void
decode_quantizer_header(struct vp8_decoder_ctx *ctx,
struct bool_decoder *bool,
struct vp8_quant_hdr *hdr)
{
int update;
int last_q = hdr->q_index;
hdr->q_index = bool_get_uint(bool, 7);
update = last_q != hdr->q_index;
update |= (hdr->y1_dc_delta_q = bool_maybe_get_int(bool, 4));
update |= (hdr->y2_dc_delta_q = bool_maybe_get_int(bool, 4));
update |= (hdr->y2_ac_delta_q = bool_maybe_get_int(bool, 4));
update |= (hdr->uv_dc_delta_q = bool_maybe_get_int(bool, 4));
update |= (hdr->uv_ac_delta_q = bool_maybe_get_int(bool, 4));
hdr->delta_update = update;
}
static void decode_and_init_token_partitions(struct vp8_decoder_ctx *ctx, struct bool_decoder *bool, const unsigned char *data, unsigned int sz, struct vp8_token_hdr *hdr)
static void decode_and_init_token_partitions（struct vp8_decoder_ctx *ctx、struct bool_decoder *bool、const unsigned char *data、unsigned int sz、struct vp8_token_hdr *hdr）
{ int i;
{int i;
hdr->partitions = 1 << bool_get_uint(bool, 2);
if (sz < 3 *(hdr->partitions - 1))
vpx_internal_error(&ctx->error, VPX_CODEC_CORRUPT_FRAME,
"Truncated packet found parsing partition"
" lengths.");
sz -= 3 * (hdr->partitions - 1);
for (i = 0; i < hdr->partitions; i++)
{
if (i < hdr->partitions - 1)
{
hdr->partition_sz[i] = (data[2] << 16)
| (data[1] << 8) | data[0];
data += 3;
}
else
hdr->partition_sz[i] = sz;
if (sz < hdr->partition_sz[i])
vpx_internal_error(&ctx->error, VPX_CODEC_CORRUPT_FRAME,
"Truncated partition %d", i);
sz -= hdr->partition_sz[i];
}
for (i = 0; i < ctx->token_hdr.partitions; i++)
{
init_bool_decoder(&ctx->tokens[i].bool, data,
ctx->token_hdr.partition_sz[i]);
data += ctx->token_hdr.partition_sz[i];
}
}
static void decode_loopfilter_header(struct vp8_decoder_ctx *ctx, struct bool_decoder *bool, struct vp8_loopfilter_hdr *hdr)
static void decode_loopfilter_header（struct vp8_decoder_ctx *ctx、struct bool_decoder *bool、struct vp8_loopfilter_hdr *hdr）
{
if (ctx->frame_hdr.is_keyframe)
memset(hdr, 0, sizeof(*hdr));
hdr->use_simple = bool_get_bit(bool);
hdr->level = bool_get_uint(bool, 6);
hdr->sharpness = bool_get_uint(bool, 3);
hdr->delta_enabled = bool_get_bit(bool);
if (hdr->delta_enabled && bool_get_bit(bool)) { int i;
if（hdr-> delta_enabled && bool_get_bit（bool））{int i;
for (i = 0; i < BLOCK_CONTEXTS; i++)
hdr->ref_delta[i] = bool_maybe_get_int(bool, 6);
for (i = 0; i < BLOCK_CONTEXTS; i++)
hdr->mode_delta[i] = bool_maybe_get_int(bool, 6);
}
}
static void
decode_segmentation_header(struct vp8_decoder_ctx *ctx,
struct bool_decoder *bool,
struct vp8_segment_hdr *hdr)
{
if (ctx->frame_hdr.is_keyframe)
memset(hdr, 0, sizeof(*hdr));
hdr->enabled = bool_get_bit(bool);
if (hdr->enabled) { int i;
if（hdr-> enabled）{int i;
hdr->update_map = bool_get_bit(bool);
hdr->update_data = bool_get_bit(bool);
if (hdr->update_data)
{
hdr->abs = bool_get_bit(bool);
for (i = 0; i < MAX_MB_SEGMENTS; i++)
hdr->quant_idx[i] = bool_maybe_get_int(bool, 7);
for (i = 0; i < MAX_MB_SEGMENTS; i++)
hdr->lf_level[i] = bool_maybe_get_int(bool, 6);
}
if (hdr->update_map)
{
for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
hdr->tree_probs[i] = bool_get_bit(bool)
? bool_get_uint(bool, 8)
: 255;
}
}
else
{
hdr->update_map = 0;
hdr->update_data = 0;
}
}
static void dequant_global_init(struct dequant_factors dqf[MAX_MB_SEGMENTS]) { int i;
static void dequant_global_init（struct dequant_factors dqf [max_mb_segments]）{int i;
for (i = 0; i < MAX_MB_SEGMENTS; i++)
dqf[i].quant_idx = -1;
}
static int clamp_q(int q) { if (q < 0) return 0; else if (q > 127) return 127;
static int clamp_q（int q）{if（q <0）return 0;else if（q> 127）127を返します。
return q; }
q;を返します。}
static int
dc_q(int q)
{
return dc_q_lookup[clamp_q(q)];
}
static int
ac_q(int q)
{
return ac_q_lookup[clamp_q(q)];
}
static void dequant_init(struct dequant_factors factors[MAX_MB_SEGMENTS], const struct vp8_segment_hdr *seg, const struct vp8_quant_hdr *quant_hdr) { int i, q; struct dequant_factors *dqf = factors;
static void dequant_init（struct dequant_factors factors [max_mb_segments]、const struct vp8_segment_hdr *seg、const struct vp8_quant_hdr *quant_hdr）{int i、q;struct dequant_factors *dqf = factors;
for (i = 0; i < (seg->enabled ? MAX_MB_SEGMENTS : 1); i++)
{
q = quant_hdr->q_index;
if (seg->enabled)
q = (!seg->abs) ? q + seg->quant_idx[i]
: seg->quant_idx[i];
if (dqf->quant_idx != q || quant_hdr->delta_update)
{
dqf->factor[TOKEN_BLOCK_Y1][0] =
dc_q(q + quant_hdr->y1_dc_delta_q);
dqf->factor[TOKEN_BLOCK_Y1][1] =
ac_q(q);
dqf->factor[TOKEN_BLOCK_UV][0] =
dc_q(q + quant_hdr->uv_dc_delta_q);
dqf->factor[TOKEN_BLOCK_UV][1] =
ac_q(q + quant_hdr->uv_ac_delta_q);
dqf->factor[TOKEN_BLOCK_Y2][0] =
dc_q(q + quant_hdr->y2_dc_delta_q) * 2;
dqf->factor[TOKEN_BLOCK_Y2][1] =
ac_q(q + quant_hdr->y2_ac_delta_q) * 155 / 100;
if (dqf->factor[TOKEN_BLOCK_Y2][1] < 8)
dqf->factor[TOKEN_BLOCK_Y2][1] = 8;
if (dqf->factor[TOKEN_BLOCK_UV][0] > 132)
dqf->factor[TOKEN_BLOCK_UV][0] = 132;
dqf->quant_idx = q;
}
dqf++;
}
}
static void
decode_frame(struct vp8_decoder_ctx *ctx,
const unsigned char *data,
unsigned int sz)
{
vpx_codec_err_t res;
struct bool_decoder bool;
int i, row, partition;
ctx->saved_entropy_valid = 0;
if ((res = vp8_parse_frame_header(data, sz, &ctx->frame_hdr)))
vpx_internal_error(&ctx->error, res,
"Failed to parse frame header");
if (ctx->frame_hdr.is_experimental) vpx_internal_error(&ctx->error, VPX_CODEC_UNSUP_BITSTREAM, "Experimental bitstreams not supported.");
if（ctx-> frame_hdr.is_experimental）vpx_internal_error（＆ctx-> error、vpx_codec_unsup_bitstream、 "実験的なbitstreamsがサポートされていない。"）;
data += FRAME_HEADER_SZ;
sz -= FRAME_HEADER_SZ;
if (ctx->frame_hdr.is_keyframe)
{
data += KEYFRAME_HEADER_SZ;
sz -= KEYFRAME_HEADER_SZ;
ctx->mb_cols = (ctx->frame_hdr.kf.w + 15) / 16;
ctx->mb_rows = (ctx->frame_hdr.kf.h + 15) / 16;
}
/* Start the bitreader for the header/entropy partition */
init_bool_decoder(&bool, data, ctx->frame_hdr.part0_sz);
/* Skip the colorspace and clamping bits */
if (ctx->frame_hdr.is_keyframe)
if (bool_get_uint(&bool, 2))
vpx_internal_error(
&ctx->error, VPX_CODEC_UNSUP_BITSTREAM,
"Reserved bits not supported.");
decode_segmentation_header(ctx, &bool, &ctx->segment_hdr);
decode_loopfilter_header(ctx, &bool, &ctx->loopfilter_hdr);
decode_and_init_token_partitions(ctx,
&bool,
data + ctx->frame_hdr.part0_sz,
sz - ctx->frame_hdr.part0_sz,
&ctx->token_hdr);
decode_quantizer_header(ctx, &bool, &ctx->quant_hdr);
decode_reference_header(ctx, &bool, &ctx->reference_hdr);
/* Set keyframe entropy defaults. These get updated on keyframes
* regardless of the refresh_entropy setting.
*/
if (ctx->frame_hdr.is_keyframe)
{
ARRAY_COPY(ctx->entropy_hdr.coeff_probs,
k_default_coeff_probs);
ARRAY_COPY(ctx->entropy_hdr.mv_probs,
k_default_mv_probs);
ARRAY_COPY(ctx->entropy_hdr.y_mode_probs,
k_default_y_mode_probs);
ARRAY_COPY(ctx->entropy_hdr.uv_mode_probs,
k_default_uv_mode_probs);
}
if (!ctx->reference_hdr.refresh_entropy)
{
ctx->saved_entropy = ctx->entropy_hdr;
ctx->saved_entropy_valid = 1;
}
decode_entropy_header(ctx, &bool, &ctx->entropy_hdr);
vp8_dixie_modemv_init(ctx);
vp8_dixie_tokens_init(ctx);
vp8_dixie_predict_init(ctx);
dequant_init(ctx->dequant_factors, &ctx->segment_hdr,
&ctx->quant_hdr);
for (row = 0, partition = 0; row < ctx->mb_rows; row++)
{
vp8_dixie_modemv_process_row(
ctx, &bool, row, 0, ctx->mb_cols);
vp8_dixie_tokens_process_row(ctx, partition, row, 0,
ctx->mb_cols);
vp8_dixie_predict_process_row(ctx, row, 0, ctx->mb_cols);
if (ctx->loopfilter_hdr.level && row)
vp8_dixie_loopfilter_process_row(ctx, row - 1, 0,
ctx->mb_cols);
if (++partition == ctx->token_hdr.partitions)
partition = 0;
}
if (ctx->loopfilter_hdr.level)
vp8_dixie_loopfilter_process_row(
ctx, row - 1, 0, ctx->mb_cols);
ctx->frame_cnt++;
if (!ctx->reference_hdr.refresh_entropy)
{
ctx->entropy_hdr = ctx->saved_entropy;
ctx->saved_entropy_valid = 0;
}
/* Handle reference frame updates */
if (ctx->reference_hdr.copy_arf == 1)
{
vp8_dixie_release_ref_frame(ctx->ref_frames[ALTREF_FRAME]);
ctx->ref_frames[ALTREF_FRAME] =
vp8_dixie_ref_frame(ctx->ref_frames[LAST_FRAME]);
}
else if (ctx->reference_hdr.copy_arf == 2)
{
vp8_dixie_release_ref_frame(ctx->ref_frames[ALTREF_FRAME]);
ctx->ref_frames[ALTREF_FRAME] =
vp8_dixie_ref_frame(ctx->ref_frames[GOLDEN_FRAME]);
}
if (ctx->reference_hdr.copy_gf == 1)
{
vp8_dixie_release_ref_frame(ctx->ref_frames[GOLDEN_FRAME]);
ctx->ref_frames[GOLDEN_FRAME] =
vp8_dixie_ref_frame(ctx->ref_frames[LAST_FRAME]);
}
else if (ctx->reference_hdr.copy_gf == 2)
{
vp8_dixie_release_ref_frame(ctx->ref_frames[GOLDEN_FRAME]);
ctx->ref_frames[GOLDEN_FRAME] =
vp8_dixie_ref_frame(ctx->ref_frames[ALTREF_FRAME]);
}
if (ctx->reference_hdr.refresh_gf)
{
vp8_dixie_release_ref_frame(ctx->ref_frames[GOLDEN_FRAME]);
ctx->ref_frames[GOLDEN_FRAME] =
vp8_dixie_ref_frame(ctx->ref_frames[CURRENT_FRAME]);
}
if (ctx->reference_hdr.refresh_arf)
{
vp8_dixie_release_ref_frame(ctx->ref_frames[ALTREF_FRAME]);
ctx->ref_frames[ALTREF_FRAME] =
vp8_dixie_ref_frame(ctx->ref_frames[CURRENT_FRAME]);
}
if (ctx->reference_hdr.refresh_last)
{
vp8_dixie_release_ref_frame(ctx->ref_frames[LAST_FRAME]);
ctx->ref_frames[LAST_FRAME] =
vp8_dixie_ref_frame(ctx->ref_frames[CURRENT_FRAME]);
}
}
}
void
vp8_dixie_decode_init(struct vp8_decoder_ctx *ctx)
{
dequant_global_init(ctx->dequant_factors);
}
#define CHECK_FOR_UPDATE(lval,rval,update_flag) do {\
unsigned int old = lval; \
update_flag |= (old != (lval = rval)); \
} while (0)
vpx_codec_err_t vp8_parse_frame_header(const unsigned char *data, unsigned int sz, struct vp8_frame_hdr *hdr) { unsigned long raw;
vpx_codec_err_t vp8_parse_frame_header（const unsigned char *data、unsigned int sz、struct vp8_frame_hdr *hdr）{unsigned long raw;
if (sz < 10) return VPX_CODEC_CORRUPT_FRAME;
if（sz <10）vpx_codec_corrupt_frameを返します。
/* The frame header is defined as a three-byte little endian
* value
*/
raw = data[0] | (data[1] << 8) | (data[2] << 16);
hdr->is_keyframe = !BITS_GET(raw, 0, 1);
hdr->version = BITS_GET(raw, 1, 2);
hdr->is_experimental = BITS_GET(raw, 3, 1);
hdr->is_shown = BITS_GET(raw, 4, 1);
hdr->part0_sz = BITS_GET(raw, 5, 19);
if (sz <= hdr->part0_sz + (hdr->is_keyframe ? 10 : 3))
return VPX_CODEC_CORRUPT_FRAME;
hdr->frame_size_updated = 0;
if (hdr->is_keyframe) { unsigned int update = 0;
if（hdr-> is_keyframe）{unsigned int update = 0;
/* Keyframe header consists of a three-byte sync code
* followed by the width and height and associated scaling
* factors.
*/
if (data[3] != 0x9d || data[4] != 0x01 || data[5] != 0x2a)
return VPX_CODEC_UNSUP_BITSTREAM;
raw = data[6] | (data[7] << 8)
| (data[8] << 16) | (data[9] << 24);
CHECK_FOR_UPDATE(hdr->kf.w, BITS_GET(raw, 0, 14),
update);
CHECK_FOR_UPDATE(hdr->kf.scale_w, BITS_GET(raw, 14, 2),
update);
CHECK_FOR_UPDATE(hdr->kf.h, BITS_GET(raw, 16, 14),
update);
CHECK_FOR_UPDATE(hdr->kf.scale_h, BITS_GET(raw, 30, 2),
update);
hdr->frame_size_updated = update;
if (!hdr->kf.w || !hdr->kf.h)
return VPX_CODEC_UNSUP_BITSTREAM;
}
return VPX_CODEC_OK; }
vpx_codec_okを返します。}
vpx_codec_err_t vp8_dixie_decode_frame(struct vp8_decoder_ctx *ctx, const unsigned char *data, unsigned int sz) { volatile struct vp8_decoder_ctx *ctx_ = ctx;
vpx_codec_err_t vp8_dixie_decode_frame（struct vp8_decoder_ctx *ctx、const unsigned char *data、unsigned int sz）{volatile struct vp8_decoder_ctx *ctx_ = ctx;
ctx->error.error_code = VPX_CODEC_OK;
ctx->error.has_detail = 0;
if (!setjmp(ctx->error.jmp))
decode_frame(ctx, data, sz);
return ctx_->error.error_code; }
ctx _-> error.error_codeを返します。}
void
vp8_dixie_decode_destroy(struct vp8_decoder_ctx *ctx)
{
vp8_dixie_predict_destroy(ctx);
vp8_dixie_tokens_destroy(ctx);
vp8_dixie_modemv_destroy(ctx);
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef DIXIE_H
#define DIXIE_H
#include "vpx_codec_internal.h"
#include "bool_decoder.h"
struct vp8_frame_hdr
{
unsigned int is_keyframe; /* Frame is a keyframe */
unsigned int is_experimental; /* Frame is a keyframe */
unsigned int version; /* Bitstream version */
unsigned int is_shown; /* Frame is to be displayed. */
unsigned int part0_sz; /* Partition 0 length, in bytes */
struct vp8_kf_hdr
{
unsigned int w; /* Width */
unsigned int h; /* Height */
unsigned int scale_w; /* Scaling factor, Width */
unsigned int scale_h; /* Scaling factor, Height */
} kf;
unsigned int frame_size_updated; /* Flag to indicate a resolution
* update.
*/
};
enum { MB_FEATURE_TREE_PROBS = 3, MAX_MB_SEGMENTS = 4 };
enum {mb_feature_tree_probs = 3、max_mb_segments = 4};
struct vp8_segment_hdr
{
unsigned int enabled;
unsigned int update_data;
unsigned int update_map;
unsigned int abs; /* 0=deltas, 1=absolute values */
unsigned int tree_probs[MB_FEATURE_TREE_PROBS];
int lf_level[MAX_MB_SEGMENTS];
int quant_idx[MAX_MB_SEGMENTS];
};
};
enum { BLOCK_CONTEXTS = 4 };
enum {block_contexts = 4};
struct vp8_loopfilter_hdr
{
unsigned int use_simple;
unsigned int level;
unsigned int sharpness;
unsigned int delta_enabled;
int ref_delta[BLOCK_CONTEXTS];
int mode_delta[BLOCK_CONTEXTS];
};
enum { MAX_PARTITIONS = 8 };
enum {max_partitions = 8};
struct vp8_token_hdr
{
unsigned int partitions;
unsigned int partition_sz[MAX_PARTITIONS];
};
struct vp8_quant_hdr
{
unsigned int q_index;
int delta_update;
int y1_dc_delta_q;
int y2_dc_delta_q;
int y2_ac_delta_q;
int uv_dc_delta_q;
int uv_ac_delta_q;
};
struct vp8_reference_hdr
{
unsigned int refresh_last;
unsigned int refresh_gf;
unsigned int refresh_arf;
unsigned int copy_gf;
unsigned int copy_arf;
unsigned int sign_bias[4];
unsigned int refresh_entropy;
};
enum { BLOCK_TYPES = 4, PREV_COEFF_CONTEXTS = 3, COEFF_BANDS = 8, ENTROPY_NODES = 11, }; typedef unsigned char coeff_probs_table_t[BLOCK_TYPES][COEFF_BANDS] [PREV_COEFF_CONTEXTS] [ENTROPY_NODES];
enum {block_types = 4、prev_coeff_contexts = 3、coeff_bands = 8、entropy_nodes = 11、};typedef unsigned char coeff_probs_table_t [block_types] [coeff_bands] [prev_coeff_contexts] [entropy_nodes];
enum
{
MV_PROB_CNT = 2 + 8 - 1 + 10 /* from entropymv.h */
};
typedef unsigned char mv_component_probs_t[MV_PROB_CNT];
struct vp8_entropy_hdr
{
coeff_probs_table_t coeff_probs;
mv_component_probs_t mv_probs[2];
unsigned int coeff_skip_enabled;
unsigned char coeff_skip_prob;
unsigned char y_mode_probs[4];
unsigned char uv_mode_probs[3];
unsigned char prob_inter;
unsigned char prob_last;
unsigned char prob_gf;
};
enum reference_frame { CURRENT_FRAME, LAST_FRAME, GOLDEN_FRAME, ALTREF_FRAME, NUM_REF_FRAMES };
enum reference_frame {current_frame、last_frame、golden_frame、altref_frame、num_ref_frames};
enum prediction_mode
{
/* 16x16 intra modes */
DC_PRED, V_PRED, H_PRED, TM_PRED, B_PRED,
/* 16x16 inter modes */
NEARESTMV, NEARMV, ZEROMV, NEWMV, SPLITMV,
MB_MODE_COUNT,
mb_mode_count、
/* 4x4 intra modes */
B_DC_PRED = 0, B_TM_PRED, B_VE_PRED, B_HE_PRED, B_LD_PRED,
B_RD_PRED, B_VR_PRED, B_VL_PRED, B_HD_PRED, B_HU_PRED,
/* 4x4 inter modes */
LEFT4X4, ABOVE4X4, ZERO4X4, NEW4X4,
B_MODE_COUNT };
b_mode_count};
enum splitmv_partitioning { SPLITMV_16X8, SPLITMV_8X16, SPLITMV_8X8, SPLITMV_4X4 };
enum splitmv_partitioning {splitmv_16x8、splitmv_8x16、splitmv_8x8、splitmv_4x4};
typedef short filter_t[6];
typedef short filter_t [6];
typedef union mv
{
struct
{
int16_t x, y;
} d;
uint32_t raw;
} mv_t;
struct mb_base_info
{
unsigned char y_mode : 4;
unsigned char uv_mode : 4;
unsigned char segment_id : 2;
unsigned char ref_frame : 2;
unsigned char skip_coeff : 1;
unsigned char need_mc_border : 1;
enum splitmv_partitioning partitioning : 2;
union mv mv;
unsigned int eob_mask;
};
struct mb_info
{
struct mb_base_info base;
union
{
union mv mvs[16];
enum prediction_mode modes[16];
} split;
};
/* A "token entropy context" has 4 Y values, 2 U, 2 V, and 1 Y2 */
typedef int token_entropy_ctx_t[4 + 2 + 2 + 1];
struct token_decoder
{
struct bool_decoder bool;
token_entropy_ctx_t left_token_entropy_ctx;
short *coeffs;
};
enum token_block_type { TOKEN_BLOCK_Y1, TOKEN_BLOCK_UV, TOKEN_BLOCK_Y2, TOKEN_BLOCK_TYPES, };
enum token_block_type {token_block_y1、token_block_uv、token_block_y2、token_block_types、};
struct dequant_factors
{
int quant_idx;
short factor[TOKEN_BLOCK_TYPES][2]; /* [ Y1, UV, Y2 ]
* [ DC, AC ] */
};
struct ref_cnt_img
{
vpx_image_t img;
unsigned int ref_cnt;
};
struct vp8_decoder_ctx { struct vpx_internal_error_info error; unsigned int frame_cnt;
struct vp8_decoder_ctx {struct vpx_internal_error_infoエラー;unsigned int frame_cnt;
struct vp8_frame_hdr frame_hdr;
struct vp8_segment_hdr segment_hdr;
struct vp8_loopfilter_hdr loopfilter_hdr;
struct vp8_token_hdr token_hdr;
struct vp8_quant_hdr quant_hdr;
struct vp8_reference_hdr reference_hdr;
struct vp8_entropy_hdr entropy_hdr;
struct vp8_entropy_hdr saved_entropy;
unsigned int saved_entropy_valid;
unsigned int mb_rows;
unsigned int mb_cols;
struct mb_info *mb_info_storage;
struct mb_info **mb_info_rows_storage;
struct mb_info **mb_info_rows;
token_entropy_ctx_t *above_token_entropy_ctx;
struct token_decoder tokens[MAX_PARTITIONS];
struct dequant_factors dequant_factors[MAX_MB_SEGMENTS];
struct ref_cnt_img frame_strg[NUM_REF_FRAMES];
struct ref_cnt_img *ref_frames[NUM_REF_FRAMES];
ptrdiff_t ref_frame_offsets[4];
const filter_t *subpixel_filters;
};
void vp8_dixie_decode_init(struct vp8_decoder_ctx *ctx);
void vp8_dixie_decode_init（struct vp8_decoder_ctx *ctx）;
void vp8_dixie_decode_destroy(struct vp8_decoder_ctx *ctx);
void vp8_dixie_decode_destroy（struct vp8_decoder_ctx *ctx）;
vpx_codec_err_t vp8_parse_frame_header(const unsigned char *data, unsigned int sz, struct vp8_frame_hdr *hdr);
VPX_CODEC_ERR_T VP8_PARSE_FRAME_HEADER（const unsigned char *data、unsigned int sz、struct vp8_frame_hdr *hdr）;
vpx_codec_err_t vp8_dixie_decode_frame(struct vp8_decoder_ctx *ctx, const unsigned char *data, unsigned int sz);
vpx_codec_err_t vp8_dixie_decode_frame（struct vp8_decoder_ctx *ctx、const unsigned char *data、unsigned int sz）;
#define CLAMP_255(x) ((x)<0?0:((x)>255?255:(x)))
#endif
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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 "dixie.h"
#include "dixie_loopfilter.h"
#define ABS(x) ((x) >= 0 ? (x) : -(x))
#define p3 pixels[-4*stride]
#define p2 pixels[-3*stride]
#define p1 pixels[-2*stride]
#define p0 pixels[-1*stride]
#define q0 pixels[ 0*stride]
#define q1 pixels[ 1*stride]
#define q2 pixels[ 2*stride]
#define q3 pixels[ 3*stride]
#define static static int
#define static static int
saturate_int8(int x)
{
if (x < -128)
return -128;
if (x > 127) return 127;
if（x> 127）127を返します。
return x; }
xを返します。}
static int saturate_uint8(int x) { if (x < 0) return 0;
static int atatrate_uint8（int x）{if（x <0）return 0;
if (x > 255) return 255;
if（x> 255）255を返します。
return x; }
xを返します。}
static int
high_edge_variance(unsigned char *pixels,
int stride,
int hev_threshold)
{
return ABS(p1 - p0) > hev_threshold ||
ABS(q1 - q0) > hev_threshold;
}
static int
simple_threshold(unsigned char *pixels,
int stride,
int filter_limit)
{
return (ABS(p0 - q0) * 2 + (ABS(p1 - q1) >> 1)) <= filter_limit;
}
static int
normal_threshold(unsigned char *pixels,
int stride,
int edge_limit,
int interior_limit)
{
int E = edge_limit;
int I = interior_limit;
return simple_threshold(pixels, stride, 2 * E + I)
&& ABS(p3 - p2) <= I && ABS(p2 - p1) <= I
&& ABS(p1 - p0) <= I && ABS(q3 - q2) <= I
&& ABS(q2 - q1) <= I && ABS(q1 - q0) <= I;
}
static void
filter_common(unsigned char *pixels,
int stride,
int use_outer_taps)
{
int a, f1, f2;
a = 3 * (q0 - p0);
if (use_outer_taps)
a += saturate_int8(p1 - q1);
a = saturate_int8(a);
f1 = ((a + 4 > 127) ? 127 : a + 4) >> 3;
f2 = ((a + 3 > 127) ? 127 : a + 3) >> 3;
p0 = saturate_uint8(p0 + f2);
q0 = saturate_uint8(q0 - f1);
if (!use_outer_taps)
{
/* This handles the case of subblock_filter()
* (from the bitstream guide.
*/
a = (f1 + 1) >> 1;
p1 = saturate_uint8(p1 + a);
q1 = saturate_uint8(q1 - a);
}
}
static void filter_mb_edge(unsigned char *pixels, int stride) { int w, a;
static void filter_mb_edge（unsigned char *pixels、int stride）{int w、a;
w = saturate_int8(saturate_int8(p1 - q1) + 3 * (q0 - p0));
a = (27 * w + 63) >> 7;
p0 = saturate_uint8(p0 + a);
q0 = saturate_uint8(q0 - a);
a = (18 * w + 63) >> 7;
p1 = saturate_uint8(p1 + a);
q1 = saturate_uint8(q1 - a);
a = (9 * w + 63) >> 7;
p2 = saturate_uint8(p2 + a);
q2 = saturate_uint8(q2 - a);
}
static void
filter_mb_v_edge(unsigned char *src,
int stride,
int edge_limit,
int interior_limit,
int hev_threshold,
int size)
{
int i;
for (i = 0; i < 8 * size; i++)
{
if (normal_threshold(src, 1, edge_limit, interior_limit))
{
if (high_edge_variance(src, 1, hev_threshold))
filter_common(src, 1, 1);
else
filter_mb_edge(src, 1);
}
src += stride;
}
}
static void
filter_subblock_v_edge(unsigned char *src,
int stride,
int edge_limit,
int interior_limit,
int hev_threshold,
int size)
{
int i;
for (i = 0; i < 8 * size; i++)
{
if (normal_threshold(src, 1, edge_limit, interior_limit))
filter_common(src, 1,
high_edge_variance(src, 1, hev_threshold));
src += stride;
}
}
static void
filter_mb_h_edge(unsigned char *src,
int stride,
int edge_limit,
int interior_limit,
int hev_threshold,
int size)
{
int i;
for (i = 0; i < 8 * size; i++)
{
if (normal_threshold(src, stride, edge_limit,
interior_limit))
{
if (high_edge_variance(src, stride, hev_threshold))
filter_common(src, stride, 1);
else
filter_mb_edge(src, stride);
}
src += 1;
}
}
static void
filter_subblock_h_edge(unsigned char *src,
int stride,
int edge_limit,
int interior_limit,
int hev_threshold,
int size)
{
int i;
for (i = 0; i < 8 * size; i++)
{
if (normal_threshold(src, stride, edge_limit,
interior_limit))
filter_common(src, stride,
high_edge_variance(src, stride,
hev_threshold));
src += 1;
}
}
static void
filter_v_edge_simple(unsigned char *src,
int stride,
int filter_limit)
{
int i;
for (i = 0; i < 16; i++)
{
if (simple_threshold(src, 1, filter_limit))
filter_common(src, 1, 1);
src += stride;
}
}
static void
filter_h_edge_simple(unsigned char *src,
int stride,
int filter_limit)
{
int i;
for (i = 0; i < 16; i++)
{
if (simple_threshold(src, stride, filter_limit))
filter_common(src, stride, 1);
src += 1;
}
}
static void calculate_filter_parameters(struct vp8_decoder_ctx *ctx, struct mb_info *mbi, int *edge_limit_, int *interior_limit_, int *hev_threshold_) { int filter_level, interior_limit, hev_threshold;
static void calculate_filter_parameters（struct vp8_decoder_ctx *ctx、struct mb_info *mbi、int *edge_limit_、int *interior_limit_、int *hev_threshold_）{int filter_level、interior_limit、hev_threshold;
/* Reference code/spec seems to conflate filter_level and
* edge_limit
*/
filter_level = ctx->loopfilter_hdr.level;
if (ctx->segment_hdr.enabled)
{
if (!ctx->segment_hdr.abs)
filter_level +=
ctx->segment_hdr.lf_level[mbi->base.segment_id];
else
filter_level =
ctx->segment_hdr.lf_level[mbi->base.segment_id];
}
if (filter_level > 63)
filter_level = 63;
else if (filter_level < 0)
filter_level = 0;
if (ctx->loopfilter_hdr.delta_enabled)
{
filter_level +=
ctx->loopfilter_hdr.ref_delta[mbi->base.ref_frame];
if (mbi->base.ref_frame == CURRENT_FRAME)
{
if (mbi->base.y_mode == B_PRED)
filter_level += ctx->loopfilter_hdr.mode_delta[0];
}
else if (mbi->base.y_mode == ZEROMV)
filter_level += ctx->loopfilter_hdr.mode_delta[1];
else if (mbi->base.y_mode == SPLITMV)
filter_level += ctx->loopfilter_hdr.mode_delta[3];
else
filter_level += ctx->loopfilter_hdr.mode_delta[2];
}
if (filter_level > 63)
filter_level = 63;
else if (filter_level < 0)
filter_level = 0;
interior_limit = filter_level;
Interior_limit = filter_level;
if (ctx->loopfilter_hdr.sharpness)
{
interior_limit >>= ctx->loopfilter_hdr.sharpness > 4 ? 2 : 1;
if (interior_limit > 9 - ctx->loopfilter_hdr.sharpness)
interior_limit = 9 - ctx->loopfilter_hdr.sharpness;
}
if (interior_limit < 1) interior_limit = 1;
if（interior_limit <1）interior_limit = 1;
hev_threshold = (filter_level >= 15);
if (filter_level >= 40)
hev_threshold++;
if (filter_level >= 20 && !ctx->frame_hdr.is_keyframe)
hev_threshold++;
*edge_limit_ = filter_level;
*interior_limit_ = interior_limit;
*hev_threshold_ = hev_threshold;
}
static void
filter_row_normal(struct vp8_decoder_ctx *ctx,
unsigned int row,
unsigned int start_col,
unsigned int num_cols)
{
unsigned char *y, *u, *v;
int stride, uv_stride;
struct mb_info *mbi;
unsigned int col;
/* Adjust pointers based on row, start_col */
stride = ctx->ref_frames[CURRENT_FRAME]->img.stride[PLANE_Y];
uv_stride = ctx->ref_frames[CURRENT_FRAME]->img.stride[PLANE_U];
y = ctx->ref_frames[CURRENT_FRAME]->img.planes[PLANE_Y];
u = ctx->ref_frames[CURRENT_FRAME]->img.planes[PLANE_U];
v = ctx->ref_frames[CURRENT_FRAME]->img.planes[PLANE_V];
y += (stride * row + start_col) * 16;
u += (uv_stride * row + start_col) * 8;
v += (uv_stride * row + start_col) * 8;
mbi = ctx->mb_info_rows[row] + start_col;
for (col = start_col; col < start_col + num_cols; col++)
{
int edge_limit, interior_limit, hev_threshold;
/* TODO: Only need to recalculate every MB if segmentation is
* enabled.
*/
calculate_filter_parameters(ctx, mbi, &edge_limit,
&interior_limit, &hev_threshold);
if (edge_limit)
{
if (col)
{
filter_mb_v_edge(y, stride, edge_limit + 2,
interior_limit, hev_threshold, 2);
filter_mb_v_edge(u, uv_stride, edge_limit + 2,
interior_limit, hev_threshold, 1);
filter_mb_v_edge(v, uv_stride, edge_limit + 2,
interior_limit, hev_threshold, 1);
}
/* NOTE: This conditional is actually dependent on the
* number of coefficients decoded, not the skip flag as
* coded in the bitstream. The tokens task is expected
* to set 31 if there is *any* non-zero data.
*/
if (mbi->base.eob_mask
|| mbi->base.y_mode == SPLITMV
|| mbi->base.y_mode == B_PRED)
{
filter_subblock_v_edge(y + 4, stride, edge_limit,
interior_limit, hev_threshold,
2);
filter_subblock_v_edge(y + 8, stride, edge_limit,
interior_limit, hev_threshold,
2);
filter_subblock_v_edge(y + 12, stride, edge_limit,
interior_limit, hev_threshold,
2);
filter_subblock_v_edge(u + 4, uv_stride, edge_limit,
interior_limit, hev_threshold,
1);
filter_subblock_v_edge(v + 4, uv_stride, edge_limit,
interior_limit, hev_threshold,
1);
}
if (row)
{
filter_mb_h_edge(y, stride, edge_limit + 2,
interior_limit, hev_threshold, 2);
filter_mb_h_edge(u, uv_stride, edge_limit + 2,
interior_limit, hev_threshold, 1);
filter_mb_h_edge(v, uv_stride, edge_limit + 2,
interior_limit, hev_threshold, 1);
}
if (mbi->base.eob_mask
|| mbi->base.y_mode == SPLITMV
|| mbi->base.y_mode == B_PRED)
{
filter_subblock_h_edge(y + 4 * stride, stride,
edge_limit, interior_limit,
hev_threshold, 2);
filter_subblock_h_edge(y + 8 * stride, stride,
edge_limit, interior_limit,
hev_threshold, 2);
filter_subblock_h_edge(y + 12 * stride, stride,
edge_limit, interior_limit,
hev_threshold, 2);
filter_subblock_h_edge(u + 4 * uv_stride, uv_stride,
edge_limit, interior_limit,
hev_threshold, 1);
filter_subblock_h_edge(v + 4 * uv_stride, uv_stride,
edge_limit, interior_limit,
hev_threshold, 1);
}
}
y += 16;
u += 8;
v += 8;
mbi++;
}
}
static void
filter_row_simple(struct vp8_decoder_ctx *ctx,
unsigned int row,
unsigned int start_col,
unsigned int num_cols)
{
unsigned char *y;
int stride;
struct mb_info *mbi;
unsigned int col;
/* Adjust pointers based on row, start_col */
stride = ctx->ref_frames[CURRENT_FRAME]->img.stride[PLANE_Y];
y = ctx->ref_frames[CURRENT_FRAME]->img.planes[PLANE_Y];
y += (stride * row + start_col) * 16;
mbi = ctx->mb_info_rows[row] + start_col;
for (col = start_col; col < start_col + num_cols; col++)
{
int edge_limit, interior_limit, hev_threshold;
/* TODO: Only need to recalculate every MB if segmentation is
* enabled.
*/
calculate_filter_parameters(ctx, mbi, &edge_limit,
&interior_limit, &hev_threshold);
if (edge_limit) {
if（edge_limit）{
/* NOTE: This conditional is actually dependent on the
* number of coefficients decoded, not the skip flag as
* coded in the bitstream. The tokens task is expected
* to set 31 if there is *any* non-zero data.
*/
int filter_subblocks = (mbi->base.eob_mask
|| mbi->base.y_mode == SPLITMV
|| mbi->base.y_mode == B_PRED);
int mb_limit = (edge_limit + 2) * 2 + interior_limit;
int b_limit = edge_limit * 2 + interior_limit;
if (col) filter_v_edge_simple(y, stride, mb_limit);
if（col）filter_v_edge_simple（y、stride、mb_limit）;
if (filter_subblocks)
{
filter_v_edge_simple(y + 4, stride, b_limit);
filter_v_edge_simple(y + 8, stride, b_limit);
filter_v_edge_simple(y + 12, stride, b_limit);
}
if (row) filter_h_edge_simple(y, stride, mb_limit);
if（row）filter_h_edge_simple（y、stride、mb_limit）;
if (filter_subblocks)
{
filter_h_edge_simple(y + 4 * stride, stride,
b_limit);
filter_h_edge_simple(y + 8 * stride, stride,
b_limit);
filter_h_edge_simple(y + 12 * stride, stride,
b_limit);
}
}
y += 16;
mbi++;
}
}
void
vp8_dixie_loopfilter_process_row(struct vp8_decoder_ctx *ctx,
unsigned int row,
unsigned int start_col,
unsigned int num_cols)
{
if (ctx->loopfilter_hdr.use_simple)
filter_row_simple(ctx, row, start_col, num_cols);
else
filter_row_normal(ctx, row, start_col, num_cols);
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef DIXIE_LOOPFILTER_H
#define DIXIE_LOOPFILTER_H
void
vp8_dixie_loopfilter_process_row(struct vp8_decoder_ctx *ctx,
unsigned int row,
unsigned int start_col,
unsigned int num_cols);
#endif
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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 "dixie.h"
#include "idct_add.h"
#include <assert.h>
void
vp8_dixie_walsh(const short *input, short *output)
{
int i;
int a1, b1, c1, d1;
int a2, b2, c2, d2;
const short *ip = input;
short *op = output;
for (i = 0; i < 4; i++)
{
a1 = ip[0] + ip[12];
b1 = ip[4] + ip[8];
c1 = ip[4] - ip[8];
d1 = ip[0] - ip[12];
op[0] = a1 + b1;
op[4] = c1 + d1;
op[8] = a1 - b1;
op[12] = d1 - c1;
ip++;
op++;
}
ip = output;
op = output;
for (i = 0; i < 4; i++)
{
a1 = ip[0] + ip[3];
b1 = ip[1] + ip[2];
c1 = ip[1] - ip[2];
d1 = ip[0] - ip[3];
a2 = a1 + b1;
b2 = c1 + d1;
c2 = a1 - b1;
d2 = d1 - c1;
op[0] = (a2 + 3) >> 3;
op[1] = (b2 + 3) >> 3;
op[2] = (c2 + 3) >> 3;
op[3] = (d2 + 3) >> 3;
ip += 4;
op += 4;
}
}
#define cospi8sqrt2minus1 20091 #define sinpi8sqrt2 35468 #define rounding 0 static void idct_columns(const short *input, short *output) { int i; int a1, b1, c1, d1;
#define cospi8sqrt2minus1 20091 #define sinpi8sqrt2 35468 #defineラウンド0 static void idct_columns（const short *input、short *output）{int i; int i;INT A1、B1、C1、D1;
const short *ip = input;
short *op = output;
int temp1, temp2;
int shortpitch = 4;
for (i = 0; i < 4; i++)
{
a1 = ip[0] + ip[8];
b1 = ip[0] - ip[8];
temp1 = (ip[4] * sinpi8sqrt2 + rounding) >> 16;
temp2 = ip[12] +
((ip[12] * cospi8sqrt2minus1 + rounding) >> 16);
c1 = temp1 - temp2;
temp1 = ip[4] +
((ip[4] * cospi8sqrt2minus1 + rounding) >> 16);
temp2 = (ip[12] * sinpi8sqrt2 + rounding) >> 16;
d1 = temp1 + temp2;
op[shortpitch*0] = a1 + d1;
op[shortpitch*3] = a1 - d1;
op[shortpitch*1] = b1 + c1;
op[shortpitch*2] = b1 - c1;
ip++;
op++;
}
}
void
vp8_dixie_idct_add(unsigned char *recon,
const unsigned char *predict,
int stride,
const short *coeffs)
{
int i;
int a1, b1, c1, d1, temp1, temp2;
short tmp[16];
idct_columns(coeffs, tmp);
coeffs = tmp;
for (i = 0; i < 4; i++)
{
a1 = coeffs[0] + coeffs[2];
b1 = coeffs[0] - coeffs[2];
temp1 = (coeffs[1] * sinpi8sqrt2 + rounding) >> 16;
temp2 = coeffs[3] +
((coeffs[3] * cospi8sqrt2minus1 + rounding) >> 16);
c1 = temp1 - temp2;
temp1 = coeffs[1] +
((coeffs[1] * cospi8sqrt2minus1 + rounding) >> 16);
temp2 = (coeffs[3] * sinpi8sqrt2 + rounding) >> 16;
d1 = temp1 + temp2;
recon[0] = CLAMP_255(predict[0] + ((a1 + d1 + 4) >> 3));
recon[3] = CLAMP_255(predict[3] + ((a1 - d1 + 4) >> 3));
recon[1] = CLAMP_255(predict[1] + ((b1 + c1 + 4) >> 3));
recon[2] = CLAMP_255(predict[2] + ((b1 - c1 + 4) >> 3));
coeffs += 4;
recon += stride;
predict += stride;
}
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef IDCT_ADD_H
#define IDCT_ADD_H
void vp8_dixie_idct_add_init(struct vp8_decoder_ctx *ctx);
void vp8_dixie_idct_add_init（struct vp8_decoder_ctx *ctx）;
void vp8_dixie_idct_add(unsigned char *recon, const unsigned char *predict, int stride, const short *coeffs);
void vp8_dixie_idct_add（unsigned char *recon、const unsigned char *predict、int stride、const short *coffs）;
void
vp8_dixie_walsh(const short *in, short *out);
void
vp8_dixie_idct_add_process_row(struct vp8_decoder_ctx *ctx,
short *coeffs,
unsigned int row,
unsigned int start_col,
unsigned int num_cols);
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef VPX_PORTS_MEM_H
#define VPX_PORTS_MEM_H
#include "vpx_config.h"
#include "vpx_integer.h"
#if defined(__GNUC__) && __GNUC__
#define DECLARE_ALIGNED(n,typ,val) typ val __attribute__ \
((aligned (n)))
#elif defined(_MSC_VER)
#define DECLARE_ALIGNED(n,typ,val) __declspec(align(n)) typ val
#else
#warning No alignment directives known for this compiler.
#define DECLARE_ALIGNED(n,typ,val) typ val
#endif
#endif
/* Declare an aligned array on the stack, for situations where the
* stack pointer may not have the alignment we expect. Creates an
* array with a modified name, then defines val to be a pointer, and
* aligns that pointer within the array.
*/
#define DECLARE_ALIGNED_ARRAY(a,typ,val,n)\
typ val##_[(n)+(a)/sizeof(typ)+1];\
typ *val = (typ*)((((intptr_t)val##_)+(a)-1)&((intptr_t)-(a)))
/* Indicates that the usage of the specified variable has been
* audited to assure that it's safe to use uninitialized. Silences
* 'may be used uninitialized' warnings on gcc.
*/
#if defined(__GNUC__) && __GNUC__
#define UNINITIALIZED_IS_SAFE(x) x=x
#else
#define UNINITIALIZED_IS_SAFE(x) x
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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 "dixie.h"
#include "modemv_data.h"
#include <stdlib.h>
#include <assert.h>
struct mv_clamp_rect { int to_left, to_right, to_top, to_bottom; };
struct mv_clamp_rect {int to_left、to_right、to_top、to_bottom;};
static union mv clamp_mv(union mv raw, const struct mv_clamp_rect *bounds) { union mv newmv;
Static Union MV CLAMP_MV（Union MV RAW、const struct MV_CLAMP_RECT *BOUNDS）{UNION MV NEWMV;
newmv.d.x = (raw.d.x < bounds->to_left)
? bounds->to_left : raw.d.x;
newmv.d.x = (raw.d.x > bounds->to_right)
? bounds->to_right : newmv.d.x;
newmv.d.y = (raw.d.y < bounds->to_top)
? bounds->to_top : raw.d.y;
newmv.d.y = (raw.d.y > bounds->to_bottom)
? bounds->to_bottom : newmv.d.y;
return newmv;
}
static int
read_segment_id(struct bool_decoder *bool,
struct vp8_segment_hdr *seg)
{
return bool_get(bool, seg->tree_probs[0])
? 2 + bool_get(bool, seg->tree_probs[2])
: bool_get(bool, seg->tree_probs[1]);
}
static enum prediction_mode
above_block_mode(const struct mb_info *this,
const struct mb_info *above,
unsigned int b)
{
if (b < 4)
{
switch (above->base.y_mode)
{
case DC_PRED:
return B_DC_PRED;
case V_PRED:
return B_VE_PRED;
case H_PRED:
return B_HE_PRED;
case TM_PRED:
return B_TM_PRED;
case B_PRED:
return above->split.modes[b+12];
default:
assert(0);
}
}
return this->split.modes[b-4]; }
これを返します - > split.modes [b-4];}
static enum prediction_mode
left_block_mode(const struct mb_info *this,
const struct mb_info *left,
unsigned int b)
{
if (!(b & 3))
{
switch (left->base.y_mode)
{
case DC_PRED:
return B_DC_PRED;
case V_PRED:
return B_VE_PRED;
case H_PRED:
return B_HE_PRED;
case TM_PRED:
return B_TM_PRED;
case B_PRED:
return left->split.modes[b+3];
default:
assert(0);
}
}
return this->split.modes[b-1]; }
これを返します - > split.modes [b-1];}
static void decode_kf_mb_mode(struct mb_info *this, struct mb_info *left, struct mb_info *above, struct bool_decoder *bool) { int y_mode, uv_mode;
static void decode_kf_mb_mode（struct mb_info *this、struct mb_info *left、struct mb_info *上記、struct bool_decoder *bool）{int y_mode、uv_mode;
y_mode = bool_read_tree(bool, kf_y_mode_tree, kf_y_mode_probs);
if (y_mode == B_PRED) { unsigned int i;
if（y_mode == b_pred）{unsigned int i;
for (i = 0; i < 16; i++)
{
enum prediction_mode a = above_block_mode(this, above,
i);
enum prediction_mode l = left_block_mode(this, left, i);
enum prediction_mode b;
b = bool_read_tree(bool, b_mode_tree,
kf_b_mode_probs[a][l]);
this->split.modes[i] = b;
}
}
uv_mode = bool_read_tree(bool, uv_mode_tree, kf_uv_mode_probs);
this->base.y_mode = y_mode;
this->base.uv_mode = uv_mode;
this->base.mv.raw = 0;
this->base.ref_frame = 0;
}
static void
decode_intra_mb_mode(struct mb_info *this,
struct vp8_entropy_hdr *hdr,
struct bool_decoder *bool)
{
/* Like decode_kf_mb_mode, but with probabilities transmitted in
* the bitstream and no context on the above/left block mode.
*/
int y_mode, uv_mode;
y_mode = bool_read_tree(bool, y_mode_tree, hdr->y_mode_probs);
if (y_mode == B_PRED) { unsigned int i;
if（y_mode == b_pred）{unsigned int i;
for (i = 0; i < 16; i++)
{
enum prediction_mode b;
b = bool_read_tree(bool, b_mode_tree,
default_b_mode_probs);
this->split.modes[i] = b;
}
}
uv_mode = bool_read_tree(bool, uv_mode_tree, hdr->uv_mode_probs);
this->base.y_mode = y_mode;
this->base.uv_mode = uv_mode;
this->base.mv.raw = 0;
this->base.ref_frame = CURRENT_FRAME;
}
static int
read_mv_component(struct bool_decoder *bool,
const unsigned char mvc[MV_PROB_CNT])
{
enum {IS_SHORT, SIGN, SHORT, BITS = SHORT + 8 - 1,
LONG_WIDTH = 10};
int x = 0;
if (bool_get(bool, mvc[IS_SHORT])) /* Large */
{
int i = 0;
for (i = 0; i < 3; i++)
x += bool_get(bool, mvc[BITS + i]) << i;
/* Skip bit 3, which is sometimes implicit */
for (i = LONG_WIDTH - 1; i > 3; i--)
x += bool_get(bool, mvc[BITS + i]) << i;
if (!(x & 0xFFF0) || bool_get(bool, mvc[BITS + 3]))
x += 8;
}
else /* small */
x = bool_read_tree(bool, small_mv_tree, mvc + SHORT);
if (x && bool_get(bool, mvc[SIGN]))
x = -x;
return x << 1;
}
static mv_t
above_block_mv(const struct mb_info *this,
const struct mb_info *above,
unsigned int b)
{
if (b < 4)
{
if (above->base.y_mode == SPLITMV)
return above->split.mvs[b+12];
return above->base.mv; }
上記のbase.mvを返します。}
return this->split.mvs[b-4]; }
これを返します - > split.mvs [b-4];}
static mv_t
left_block_mv(const struct mb_info *this,
const struct mb_info *left,
unsigned int b)
{
if (!(b & 3))
{
if (left->base.y_mode == SPLITMV)
return left->split.mvs[b+3];
return left->base.mv; }
左> base.mvを返します。}
return this->split.mvs[b-1]; }
これを返します - > split.mvs [b-1];}
static enum prediction_mode
submv_ref(struct bool_decoder *bool, union mv l, union mv a)
{
enum subblock_mv_ref
{
SUBMVREF_NORMAL,
SUBMVREF_LEFT_ZED,
SUBMVREF_ABOVE_ZED,
SUBMVREF_LEFT_ABOVE_SAME,
SUBMVREF_LEFT_ABOVE_ZED
};
int lez = !(l.raw);
int aez = !(a.raw);
int lea = l.raw == a.raw;
enum subblock_mv_ref ctx = SUBMVREF_NORMAL;
if (lea && lez)
ctx = SUBMVREF_LEFT_ABOVE_ZED;
else if (lea)
ctx = SUBMVREF_LEFT_ABOVE_SAME;
else if (aez)
ctx = SUBMVREF_ABOVE_ZED;
else if (lez)
ctx = SUBMVREF_LEFT_ZED;
return bool_read_tree(bool, submv_ref_tree, submv_ref_probs2[ctx]); }
return bool_read_tree（bool、submv_ref_tree、submv_ref_probs2 [ctx]）;}
static void
read_mv(struct bool_decoder *bool,
union mv *mv,
mv_component_probs_t mvc[2])
{
mv->d.y = read_mv_component(bool, mvc[0]);
mv->d.x = read_mv_component(bool, mvc[1]);
}
static void
mv_bias(const struct mb_info *mb,
const unsigned int sign_bias[3],
enum reference_frame ref_frame,
union mv *mv)
{
if (sign_bias[mb->base.ref_frame] ^ sign_bias[ref_frame])
{
mv->d.x *= -1;
mv->d.y *= -1;
}
}
enum near_mv_v { CNT_BEST = 0, CNT_ZEROZERO = 0, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
enum near_mv_v {cnt_best = 0、cnt_zerozero = 0、cnt_nearest、cnt_near、cnt_splitmv};
static void
find_near_mvs(const struct mb_info *this,
const struct mb_info *left,
const struct mb_info *above,
const unsigned int sign_bias[3],
union mv near_mvs[4],
int cnt[4])
{
const struct mb_info *aboveleft = above - 1;
union mv *mv = near_mvs;
int *cntx = cnt;
/* Zero accumulators */
mv[0].raw = mv[1].raw = mv[2].raw = 0;
cnt[0] = cnt[1] = cnt[2] = cnt[3] = 0;
/* Process above */
if (above->base.ref_frame != CURRENT_FRAME)
{
if (above->base.mv.raw)
{
(++mv)->raw = above->base.mv.raw;
mv_bias(above, sign_bias, this->base.ref_frame, mv);
++cntx;
}
*cntx += 2;
}
/* Process left */
if (left->base.ref_frame != CURRENT_FRAME)
{
if (left->base.mv.raw)
{
union mv this_mv;
this_mv.raw = left->base.mv.raw;
mv_bias(left, sign_bias, this->base.ref_frame, &this_mv);
if (this_mv.raw != mv->raw)
{
(++mv)->raw = this_mv.raw;
++cntx;
}
*cntx += 2;
}
else
cnt[CNT_ZEROZERO] += 2;
}
/* Process above left */
if (aboveleft->base.ref_frame != CURRENT_FRAME)
{
if (aboveleft->base.mv.raw)
{
union mv this_mv;
this_mv.raw = aboveleft->base.mv.raw;
mv_bias(aboveleft, sign_bias, this->base.ref_frame,
&this_mv);
if (this_mv.raw != mv->raw)
{
(++mv)->raw = this_mv.raw;
++cntx;
}
*cntx += 1;
}
else
cnt[CNT_ZEROZERO] += 1;
}
/* If we have three distinct MVs ... */
if (cnt[CNT_SPLITMV])
{
/* See if above-left MV can be merged with NEAREST */
if (mv->raw == near_mvs[CNT_NEAREST].raw)
cnt[CNT_NEAREST] += 1;
}
cnt[CNT_SPLITMV] = ((above->base.y_mode == SPLITMV)
+ (left->base.y_mode == SPLITMV)) * 2
+ (aboveleft->base.y_mode == SPLITMV);
/* Swap near and nearest if necessary */
if (cnt[CNT_NEAR] > cnt[CNT_NEAREST])
{
int tmp;
tmp = cnt[CNT_NEAREST];
cnt[CNT_NEAREST] = cnt[CNT_NEAR];
cnt[CNT_NEAR] = tmp;
tmp = near_mvs[CNT_NEAREST].raw;
near_mvs[CNT_NEAREST].raw = near_mvs[CNT_NEAR].raw;
near_mvs[CNT_NEAR].raw = tmp;
}
/* Use near_mvs[CNT_BEST] to store the "best" MV. Note that this
* storage shares the same address as near_mvs[CNT_ZEROZERO].
*/
if (cnt[CNT_NEAREST] >= cnt[CNT_BEST])
near_mvs[CNT_BEST] = near_mvs[CNT_NEAREST];
}
static void decode_split_mv(struct mb_info *this, const struct mb_info *left, const struct mb_info *above, struct vp8_entropy_hdr *hdr, union mv *best_mv, struct bool_decoder *bool) { const int *partition; int j, k, mask, partition_id;
static void decode_split_mv（struct mb_info *this、const struct mb_info *left、const struct mb_info *上記、struct vp8_entropy_hdr *hdr、union mv *best_mv、struct bool_decoder *bool）{const int *partition;Int J、K、Mask、partition_id;
partition_id = bool_read_tree(bool, split_mv_tree,
split_mv_probs);
partition = mv_partitions[partition_id];
this->base.partitioning = partition_id;
for (j = 0, mask = 0; mask < 65535; j++)
{
union mv mv, left_mv, above_mv;
enum prediction_mode subblock_mode;
/* Find the first subblock in this partition. */
for (k = 0; j != partition[k]; k++);
/* Decode the next MV */
left_mv = left_block_mv(this, left, k);
above_mv = above_block_mv(this, above, k);
subblock_mode = submv_ref(bool, left_mv, above_mv);
switch (subblock_mode)
{
case LEFT4X4:
mv = left_mv;
break;
case ABOVE4X4:
mv = above_mv;
break;
case ZERO4X4:
mv.raw = 0;
break;
case NEW4X4:
read_mv(bool, &mv, hdr->mv_probs);
mv.d.x += best_mv->d.x;
mv.d.y += best_mv->d.y;
break;
default:
assert(0);
}
/* Fill the MVs for this partition */
for (; k < 16; k++)
if (j == partition[k])
{
this->split.mvs[k] = mv;
mask |= 1 << k;
}
}
}
static int need_mc_border(union mv mv, int l, int t, int b_w, int w, int h) { int b, r;
static int need_mc_border（Union MV MV、int l、int t、int b_w、int w、int h）{int b、r;
/* Get distance to edge for top-left pixel */
l += (mv.d.x >> 3);
t += (mv.d.y >> 3);
/* Get distance to edge for bottom-right pixel */
r = w - (l + b_w);
b = h - (t + b_w);
return (l >> 1 < 2 || r >> 1 < 3 || t >> 1 < 2 || b >> 1 < 3);
}
static void
decode_mvs(struct vp8_decoder_ctx *ctx,
struct mb_info *this,
const struct mb_info *left,
const struct mb_info *above,
const struct mv_clamp_rect *bounds,
struct bool_decoder *bool)
{
struct vp8_entropy_hdr *hdr = &ctx->entropy_hdr;
union mv near_mvs[4];
union mv clamped_best_mv;
int mv_cnts[4];
unsigned char probs[4];
enum {BEST, NEAREST, NEAR};
int x, y, w, h, b;
this->base.ref_frame = bool_get(bool, hdr->prob_last)
? 2 + bool_get(bool, hdr->prob_gf)
: 1;
find_near_mvs(this, this - 1, above,
ctx->reference_hdr.sign_bias, near_mvs, mv_cnts);
probs[0] = mv_counts_to_probs[mv_cnts[0]][0];
probs[1] = mv_counts_to_probs[mv_cnts[1]][1];
probs[2] = mv_counts_to_probs[mv_cnts[2]][2];
probs[3] = mv_counts_to_probs[mv_cnts[3]][3];
this->base.y_mode = bool_read_tree(bool, mv_ref_tree, probs);
this->base.uv_mode = this->base.y_mode;
this->base.need_mc_border = 0;
x = (-bounds->to_left - 128) >> 3;
y = (-bounds->to_top - 128) >> 3;
w = ctx->mb_cols * 16;
h = ctx->mb_rows * 16;
switch (this->base.y_mode)
{
case NEARESTMV:
this->base.mv = clamp_mv(near_mvs[NEAREST], bounds);
break;
case NEARMV:
this->base.mv = clamp_mv(near_mvs[NEAR], bounds);
break;
case ZEROMV:
this->base.mv.raw = 0;
return; //skip need_mc_border check
case NEWMV:
clamped_best_mv = clamp_mv(near_mvs[BEST], bounds);
read_mv(bool, &this->base.mv, hdr->mv_probs);
this->base.mv.d.x += clamped_best_mv.d.x;
this->base.mv.d.y += clamped_best_mv.d.y;
break;
case SPLITMV:
{
union mv chroma_mv[4] = {{{0}}};
clamped_best_mv = clamp_mv(near_mvs[BEST], bounds);
decode_split_mv(this, left, above, hdr, &clamped_best_mv,
bool);
this->base.mv = this->split.mvs[15];
for (b = 0; b < 16; b++)
{
chroma_mv[(b>>1&1) + (b>>2&2)].d.x +=
this->split.mvs[b].d.x;
chroma_mv[(b>>1&1) + (b>>2&2)].d.y +=
this->split.mvs[b].d.y;
if (need_mc_border(this->split.mvs[b],
x + (b & 3) * 4, y + (b & ~3), 4, w, h))
{
this->base.need_mc_border = 1;
break;
}
}
for (b = 0; b < 4; b++)
{
chroma_mv[b].d.x += 4 + 8 * (chroma_mv[b].d.x >> 31);
chroma_mv[b].d.y += 4 + 8 * (chroma_mv[b].d.y >> 31);
chroma_mv[b].d.x /= 4;
chroma_mv[b].d.y /= 4;
//note we're passing in non-subsampled coordinates
//ノンサブサンプル座標を通過することに注意してください
if (need_mc_border(chroma_mv[b],
x + (b & 1) * 8, y + (b >> 1) * 8, 16, w, h))
{
this->base.need_mc_border = 1;
break;
}
}
return; //skip need_mc_border check
}
default:
assert(0);
}
if (need_mc_border(this->base.mv, x, y, 16, w, h))
this->base.need_mc_border = 1;
}
void
vp8_dixie_modemv_process_row(struct vp8_decoder_ctx *ctx,
struct bool_decoder *bool,
int row,
int start_col,
int num_cols)
{
struct mb_info *above, *this;
unsigned int col;
struct mv_clamp_rect bounds;
this = ctx->mb_info_rows[row] + start_col;
above = ctx->mb_info_rows[row - 1] + start_col;
/* Calculate the eighth-pel MV bounds using a 1 MB border. */
bounds.to_left = -((start_col + 1) << 7);
bounds.to_right = (ctx->mb_cols - start_col) << 7;
bounds.to_top = -((row + 1) << 7);
bounds.to_bottom = (ctx->mb_rows - row) << 7;
for (col = start_col; col < start_col + num_cols; col++)
{
if (ctx->segment_hdr.update_map)
this->base.segment_id = read_segment_id(bool,
&ctx->segment_hdr);
if (ctx->entropy_hdr.coeff_skip_enabled)
this->base.skip_coeff = bool_get(bool,
ctx->entropy_hdr.coeff_skip_prob);
if (ctx->frame_hdr.is_keyframe)
{
if (!ctx->segment_hdr.update_map)
this->base.segment_id = 0;
decode_kf_mb_mode(this, this - 1, above, bool);
}
else
{
if (bool_get(bool, ctx->entropy_hdr.prob_inter))
decode_mvs(ctx, this, this - 1, above, &bounds,
bool);
else
decode_intra_mb_mode(this, &ctx->entropy_hdr, bool);
bounds.to_left -= 16 << 3;
bounds.to_right -= 16 << 3;
}
/* Advance to next mb */
this++;
above++;
}
}
void vp8_dixie_modemv_init(struct vp8_decoder_ctx *ctx) { unsigned int mbi_w, mbi_h, i; struct mb_info *mbi;
void vp8_dixie_modemv_init（struct vp8_decoder_ctx *ctx）{unsigned int mbi_w、mbi_h、i;struct mb_info *mbi;
mbi_w = ctx->mb_cols + 1; /* For left border col */
mbi_h = ctx->mb_rows + 1; /* For above border row */
if (ctx->frame_hdr.frame_size_updated)
{
free(ctx->mb_info_storage);
ctx->mb_info_storage = NULL;
free(ctx->mb_info_rows_storage);
ctx->mb_info_rows_storage = NULL;
}
if (!ctx->mb_info_storage)
ctx->mb_info_storage = calloc(mbi_w * mbi_h,
sizeof(*ctx->mb_info_storage));
if (!ctx->mb_info_rows_storage)
if（！ctx-> mb_info_rows_storage）
ctx->mb_info_rows_storage = calloc(mbi_h,
sizeof(*ctx->mb_info_rows_storage));
/* Set up row pointers */
mbi = ctx->mb_info_storage + 1;
for (i = 0; i < mbi_h; i++)
{
ctx->mb_info_rows_storage[i] = mbi;
mbi += mbi_w;
}
ctx->mb_info_rows = ctx->mb_info_rows_storage + 1;
}
void
vp8_dixie_modemv_destroy(struct vp8_decoder_ctx *ctx)
{
free(ctx->mb_info_storage);
ctx->mb_info_storage = NULL;
free(ctx->mb_info_rows_storage);
ctx->mb_info_rows_storage = NULL;
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef MODEMV_H
#define MODEMV_H
void vp8_dixie_modemv_init(struct vp8_decoder_ctx *ctx);
void vp8_dixie_modemv_init（struct vp8_decoder_ctx *ctx）;
void vp8_dixie_modemv_destroy(struct vp8_decoder_ctx *ctx);
void vp8_dixie_modemv_destroy（struct vp8_decoder_ctx *ctx）;
void
vp8_dixie_modemv_process_row(struct vp8_decoder_ctx *ctx,
struct bool_decoder *bool,
int row,
int start_col,
int num_cols);
#endif
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
static const unsigned char kf_y_mode_probs[] = { 145, 156, 163, 128};
static const unsigned char kf_uv_mode_probs[] = { 142, 114, 183};
static const unsigned char kf_b_mode_probs[10][10][9] =
{
{ /* above mode 0 */
{ /* left mode 0 */ 231, 120, 48, 89, 115, 113, 120, 152, 112},
{ /* left mode 1 */ 152, 179, 64, 126, 170, 118, 46, 70, 95},
{ /* left mode 2 */ 175, 69, 143, 80, 85, 82, 72, 155, 103},
{ /* left mode 3 */ 56, 58, 10, 171, 218, 189, 17, 13, 152},
{ /* left mode 4 */ 144, 71, 10, 38, 171, 213, 144, 34, 26},
{ /* left mode 5 */ 114, 26, 17, 163, 44, 195, 21, 10, 173},
{ /* left mode 6 */ 121, 24, 80, 195, 26, 62, 44, 64, 85},
{ /* left mode 7 */ 170, 46, 55, 19, 136, 160, 33, 206, 71},
{ /* left mode 8 */ 63, 20, 8, 114, 114, 208, 12, 9, 226},
{ /* left mode 9 */ 81, 40, 11, 96, 182, 84, 29, 16, 36}
},
{ /* above mode 1 */
{ /* left mode 0 */ 134, 183, 89, 137, 98, 101, 106, 165, 148},
{ /* left mode 1 */ 72, 187, 100, 130, 157, 111, 32, 75, 80},
{ /* left mode 2 */ 66, 102, 167, 99, 74, 62, 40, 234, 128},
{ /* left mode 3 */ 41, 53, 9, 178, 241, 141, 26, 8, 107},
{ /* left mode 4 */ 104, 79, 12, 27, 217, 255, 87, 17, 7},
{ /* left mode 5 */ 74, 43, 26, 146, 73, 166, 49, 23, 157},
{ /* left mode 6 */ 65, 38, 105, 160, 51, 52, 31, 115, 128},
{ /* left mode 7 */ 87, 68, 71, 44, 114, 51, 15, 186, 23},
{ /* left mode 8 */ 47, 41, 14, 110, 182, 183, 21, 17, 194},
{ /* left mode 9 */ 66, 45, 25, 102, 197, 189, 23, 18, 22}
},
{ /* above mode 2 */
{ /* left mode 0 */ 88, 88, 147, 150, 42, 46, 45, 196, 205},
{ /* left mode 1 */ 43, 97, 183, 117, 85, 38, 35, 179, 61},
{ /* left mode 2 */ 39, 53, 200, 87, 26, 21, 43, 232, 171},
{ /* left mode 3 */ 56, 34, 51, 104, 114, 102, 29, 93, 77},
{ /* left mode 4 */ 107, 54, 32, 26, 51, 1, 81, 43, 31},
{ /* left mode 5 */ 39, 28, 85, 171, 58, 165, 90, 98, 64},
{ /* left mode 6 */ 34, 22, 116, 206, 23, 34, 43, 166, 73},
{ /* left mode 7 */ 68, 25, 106, 22, 64, 171, 36, 225, 114},
{ /* left mode 8 */ 34, 19, 21, 102, 132, 188, 16, 76, 124},
{ /* left mode 9 */ 62, 18, 78, 95, 85, 57, 50, 48, 51}
},
{ /* above mode 3 */
{ /* left mode 0 */ 193, 101, 35, 159, 215, 111, 89, 46, 111},
{ /* left mode 1 */ 60, 148, 31, 172, 219, 228, 21, 18, 111},
{ /* left mode 2 */ 112, 113, 77, 85, 179, 255, 38, 120, 114},
{ /* left mode 3 */ 40, 42, 1, 196, 245, 209, 10, 25, 109},
{ /* left mode 4 */ 100, 80, 8, 43, 154, 1, 51, 26, 71},
{ /* left mode 5 */ 88, 43, 29, 140, 166, 213, 37, 43, 154},
{ /* left mode 6 */ 61, 63, 30, 155, 67, 45, 68, 1, 209},
{ /* left mode 7 */ 142, 78, 78, 16, 255, 128, 34, 197, 171},
{ /* left mode 8 */ 41, 40, 5, 102, 211, 183, 4, 1, 221},
{ /* left mode 9 */ 51, 50, 17, 168, 209, 192, 23, 25, 82}
},
{ /* above mode 4 */
{ /* left mode 0 */ 125, 98, 42, 88, 104, 85, 117, 175, 82},
{ /* left mode 1 */ 95, 84, 53, 89, 128, 100, 113, 101, 45},
{ /* left mode 2 */ 75, 79, 123, 47, 51, 128, 81, 171, 1},
{ /* left mode 3 */ 57, 17, 5, 71, 102, 57, 53, 41, 49},
{ /* left mode 4 */ 115, 21, 2, 10, 102, 255, 166, 23, 6},
{ /* left mode 5 */ 38, 33, 13, 121, 57, 73, 26, 1, 85},
{ /* left mode 6 */ 41, 10, 67, 138, 77, 110, 90, 47, 114},
{ /* left mode 7 */ 101, 29, 16, 10, 85, 128, 101, 196, 26},
{ /* left mode 8 */ 57, 18, 10, 102, 102, 213, 34, 20, 43},
{ /* left mode 9 */ 117, 20, 15, 36, 163, 128, 68, 1, 26}
},
{ /* above mode 5 */
{ /* left mode 0 */ 138, 31, 36, 171, 27, 166, 38, 44, 229},
{ /* left mode 1 */ 67, 87, 58, 169, 82, 115, 26, 59, 179},
{ /* left mode 2 */ 63, 59, 90, 180, 59, 166, 93, 73, 154},
{ /* left mode 3 */ 40, 40, 21, 116, 143, 209, 34, 39, 175},
{ /* left mode 4 */ 57, 46, 22, 24, 128, 1, 54, 17, 37},
{ /* left mode 5 */ 47, 15, 16, 183, 34, 223, 49, 45, 183},
{ /* left mode 6 */ 46, 17, 33, 183, 6, 98, 15, 32, 183},
{ /* left mode 7 */ 65, 32, 73, 115, 28, 128, 23, 128, 205},
{ /* left mode 8 */ 40, 3, 9, 115, 51, 192, 18, 6, 223},
{ /* left mode 9 */ 87, 37, 9, 115, 59, 77, 64, 21, 47}
},
{ /* above mode 6 */
{ /* left mode 0 */ 104, 55, 44, 218, 9, 54, 53, 130, 226},
{ /* left mode 1 */ 64, 90, 70, 205, 40, 41, 23, 26, 57},
{ /* left mode 2 */ 54, 57, 112, 184, 5, 41, 38, 166, 213},
{ /* left mode 3 */ 30, 34, 26, 133, 152, 116, 10, 32, 134},
{ /* left mode 4 */ 75, 32, 12, 51, 192, 255, 160, 43, 51},
{ /* left mode 5 */ 39, 19, 53, 221, 26, 114, 32, 73, 255},
{ /* left mode 6 */ 31, 9, 65, 234, 2, 15, 1, 118, 73},
{ /* left mode 7 */ 88, 31, 35, 67, 102, 85, 55, 186, 85},
{ /* left mode 8 */ 56, 21, 23, 111, 59, 205, 45, 37, 192},
{ /* left mode 9 */ 55, 38, 70, 124, 73, 102, 1, 34, 98}
},
{ /* above mode 7 */
{ /* left mode 0 */ 102, 61, 71, 37, 34, 53, 31, 243, 192},
{ /* left mode 1 */ 69, 60, 71, 38, 73, 119, 28, 222, 37},
{ /* left mode 2 */ 68, 45, 128, 34, 1, 47, 11, 245, 171},
{ /* left mode 3 */ 62, 17, 19, 70, 146, 85, 55, 62, 70},
{ /* left mode 4 */ 75, 15, 9, 9, 64, 255, 184, 119, 16},
{ /* left mode 5 */ 37, 43, 37, 154, 100, 163, 85, 160, 1},
{ /* left mode 6 */ 63, 9, 92, 136, 28, 64, 32, 201, 85},
{ /* left mode 7 */ 86, 6, 28, 5, 64, 255, 25, 248, 1},
{ /* left mode 8 */ 56, 8, 17, 132, 137, 255, 55, 116, 128},
{ /* left mode 9 */ 58, 15, 20, 82, 135, 57, 26, 121, 40}
},
{ /* above mode 8 */
{ /* left mode 0 */ 164, 50, 31, 137, 154, 133, 25, 35, 218},
{ /* left mode 1 */ 51, 103, 44, 131, 131, 123, 31, 6, 158},
{ /* left mode 2 */ 86, 40, 64, 135, 148, 224, 45, 183, 128},
{ /* left mode 3 */ 22, 26, 17, 131, 240, 154, 14, 1, 209},
{ /* left mode 4 */ 83, 12, 13, 54, 192, 255, 68, 47, 28},
{ /* left mode 5 */ 45, 16, 21, 91, 64, 222, 7, 1, 197},
{ /* left mode 6 */ 56, 21, 39, 155, 60, 138, 23, 102, 213},
{ /* left mode 7 */ 85, 26, 85, 85, 128, 128, 32, 146, 171},
{ /* left mode 8 */ 18, 11, 7, 63, 144, 171, 4, 4, 246},
{ /* left mode 9 */ 35, 27, 10, 146, 174, 171, 12, 26, 128}
},
{ /* above mode 9 */
{ /* left mode 0 */ 190, 80, 35, 99, 180, 80, 126, 54, 45},
{ /* left mode 1 */ 85, 126, 47, 87, 176, 51, 41, 20, 32},
{ /* left mode 2 */ 101, 75, 128, 139, 118, 146, 116, 128, 85},
{ /* left mode 3 */ 56, 41, 15, 176, 236, 85, 37, 9, 62},
{ /* left mode 4 */ 146, 36, 19, 30, 171, 255, 97, 27, 20},
{ /* left mode 5 */ 71, 30, 17, 119, 118, 255, 17, 18, 138},
{ /* left mode 6 */ 101, 38, 60, 138, 55, 70, 43, 26, 142},
{ /* left mode 7 */ 138, 45, 61, 62, 219, 1, 81, 188, 64},
{ /* left mode 8 */ 32, 41, 20, 117, 151, 142, 20, 21, 163},
{ /* left mode 9 */ 112, 19, 12, 61, 195, 128, 48, 4, 24}
}
};
static const int kf_y_mode_tree[] =
{
-B_PRED, 2,
4, 6,
-DC_PRED, -V_PRED,
-H_PRED, -TM_PRED
};
static const int y_mode_tree[] =
{
-DC_PRED, 2,
4, 6,
-V_PRED, -H_PRED,
-TM_PRED, -B_PRED
};
static const int uv_mode_tree[6] =
{
-DC_PRED, 2,
-V_PRED, 4,
-H_PRED, -TM_PRED
};
static const int b_mode_tree[18] =
{
-B_DC_PRED, 2, /* 0 = DC_NODE */
-B_TM_PRED, 4, /* 1 = TM_NODE */
-B_VE_PRED, 6, /* 2 = VE_NODE */
8, 12, /* 3 = COM_NODE */
-B_HE_PRED, 10, /* 4 = HE_NODE */
-B_RD_PRED, -B_VR_PRED, /* 5 = RD_NODE */
-B_LD_PRED, 14, /* 6 = LD_NODE */
-B_VL_PRED, 16, /* 7 = VL_NODE */
-B_HD_PRED, -B_HU_PRED /* 8 = HD_NODE */
};
static const int small_mv_tree[14] =
{
2, 8,
4, 6,
-0, -1,
-2, -3,
10, 12,
-4, -5,
-6, -7
};
static const int mv_ref_tree[8] =
{
-ZEROMV, 2,
-NEARESTMV, 4,
-NEARMV, 6,
-NEWMV, -SPLITMV
};
static const int submv_ref_tree[6] =
{
-LEFT4X4, 2,
-ABOVE4X4, 4,
-ZERO4X4, -NEW4X4
};
static const int split_mv_tree[6] =
{
-3, 2,
-2, 4,
-0, -1
};
static const unsigned char default_b_mode_probs[] =
{ 120, 90, 79, 133, 87, 85, 80, 111, 151};
static const unsigned char mv_counts_to_probs[6][4] =
{
{ 7, 1, 1, 143 },
{ 14, 18, 14, 107 },
{ 135, 64, 57, 68 },
{ 60, 56, 128, 65 },
{ 159, 134, 128, 34 },
{ 234, 188, 128, 28 }
};
static const unsigned char split_mv_probs[3] =
{ 110, 111, 150};
static const unsigned char submv_ref_probs2[5][3] =
{
{ 147, 136, 18 },
{ 106, 145, 1 },
{ 179, 121, 1 },
{ 223, 1, 34 },
{ 208, 1, 1 }
};
const static int mv_partitions[4][16] =
{
{0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 },
{0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 },
{0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3 },
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
};
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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 "dixie.h"
#include "predict.h"
#include "idct_add.h"
#include "mem.h"
#include <assert.h>
#include <string.h>
enum { BORDER_PIXELS = 16, };
enum {border_pixels = 16、};
static const filter_t sixtap_filters[8] =
{
{ 0, 0, 128, 0, 0, 0 },
{ 0, -6, 123, 12, -1, 0 },
{ 2, -11, 108, 36, -8, 1 },
{ 0, -9, 93, 50, -6, 0 },
{ 3, -16, 77, 77, -16, 3 },
{ 0, -6, 50, 93, -9, 0 },
{ 1, -8, 36, 108, -11, 2 },
{ 0, -1, 12, 123, -6, 0 }
};
static const filter_t bilinear_filters[8] =
{
{ 0, 0, 128, 0, 0, 0 },
{ 0, 0, 112, 16, 0, 0 },
{ 0, 0, 96, 32, 0, 0 },
{ 0, 0, 80, 48, 0, 0 },
{ 0, 0, 64, 64, 0, 0 },
{ 0, 0, 48, 80, 0, 0 },
{ 0, 0, 32, 96, 0, 0 },
{ 0, 0, 16, 112, 0, 0 }
};
static void
predict_h_nxn(unsigned char *predict,
int stride,
int n)
{
unsigned char *left = predict - 1;
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
predict[i *stride + j] = left[i * stride];
}
static void
predict_v_nxn(unsigned char *predict,
int stride,
int n)
{
unsigned char *above = predict - stride;
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
predict[i *stride + j] = above[j];
}
static void
predict_tm_nxn(unsigned char *predict,
int stride,
int n)
{
/* Transposes the left column to the top row for later
* consumption by the idct/recon stage
*/
unsigned char *left = predict - 1;
unsigned char *above = predict - stride;
unsigned char p = above[-1];
int i, j;
for (j = 0; j < n; j++)
{
for (i = 0; i < n; i++)
predict[i] = CLAMP_255(*left + above[i] - p);
predict += stride;
left += stride;
}
}
static void
predict_dc_nxn(unsigned char *predict,
int stride,
int n)
{
unsigned char *left = predict - 1;
unsigned char *above = predict - stride;
int i, j, dc = 0;
for (i = 0; i < n; i++)
{
dc += *left + above[i];
left += stride;
}
switch (n)
{
case 16:
dc = (dc + 16) >> 5;
break;
case 8:
dc = (dc + 8) >> 4;
break;
case 4:
dc = (dc + 4) >> 3;
break;
}
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
predict[i *stride + j] = dc;
}
static void
predict_ve_4x4(unsigned char *predict,
int stride)
{
unsigned char *above = predict - stride;
int i, j;
predict[0] = (above[-1] + 2 * above[0] + above[1] + 2) >> 2;
predict[1] = (above[ 0] + 2 * above[1] + above[2] + 2) >> 2;
predict[2] = (above[ 1] + 2 * above[2] + above[3] + 2) >> 2;
predict[3] = (above[ 2] + 2 * above[3] + above[4] + 2) >> 2;
for (i = 1; i < 4; i++)
for (j = 0; j < 4; j++)
predict[i *stride + j] = predict[j];
}
static void
predict_he_4x4(unsigned char *predict,
int stride)
{
unsigned char *left = predict - 1;
predict[0] =
predict[1] =
predict[2] =
predict[3] = (left[-stride] + 2 * left[0] +
left[stride] + 2) >> 2;
predict += stride;
left += stride;
predict[0] =
predict[1] =
predict[2] =
predict[3] = (left[-stride] + 2 * left[0] +
left[stride] + 2) >> 2;
predict += stride;
left += stride;
predict[0] =
predict[1] =
predict[2] =
predict[3] = (left[-stride] + 2 * left[0] +
left[stride] + 2) >> 2;
predict += stride;
left += stride;
predict[0] =
predict[1] =
predict[2] =
predict[3] = (left[-stride] + 2 * left[0] + left[0] + 2) >> 2;
}
static void
predict_ld_4x4(unsigned char *predict,
int stride)
{
unsigned char *above = predict - stride;
int pred0, pred1, pred2, pred3, pred4, pred5, pred6;
predict[0] = pred0 = (above[0] + 2 * above[1] +
above[2] + 2) >> 2;
predict[1] = pred1 = (above[1] + 2 * above[2] +
above[3] + 2) >> 2;
predict[2] = pred2 = (above[2] + 2 * above[3] +
above[4] + 2) >> 2;
predict[3] = pred3 = (above[3] + 2 * above[4] +
above[5] + 2) >> 2;
predict += stride;
predict[0] = pred1;
predict[1] = pred2;
predict[2] = pred3;
predict[3] = pred4 = (above[4] + 2 * above[5] +
above[6] + 2) >> 2;
predict += stride;
predict[0] = pred2;
predict[1] = pred3;
predict[2] = pred4;
predict[3] = pred5 = (above[5] + 2 * above[6] +
above[7] + 2) >> 2;
predict += stride;
predict[0] = pred3;
predict[1] = pred4;
predict[2] = pred5;
predict[3] = pred6 = (above[6] + 2 * above[7] +
above[7] + 2) >> 2;
}
static void
predict_rd_4x4(unsigned char *predict,
int stride)
{
unsigned char *left = predict - 1;
unsigned char *above = predict - stride;
int pred0, pred1, pred2, pred3, pred4, pred5, pred6;
predict[0] = pred0 =
(left[ 0] + 2 * above[-1] + above[0] + 2) >> 2;
predict[1] = pred1 =
(above[-1] + 2 * above[ 0] + above[1] + 2) >> 2;
predict[2] = pred2 =
(above[ 0] + 2 * above[ 1] + above[2] + 2) >> 2;
predict[3] = pred3 =
(above[ 1] + 2 * above[ 2] + above[3] + 2) >> 2;
predict += stride;
predict[0] = pred4 =
(left[stride] + 2 * left[0] + above[-1] + 2) >> 2;
predict[1] = pred0;
predict[2] = pred1;
predict[3] = pred2;
predict += stride;
predict[0] = pred5 =
(left[stride*2] + 2 * left[stride] + left[0] + 2) >> 2;
predict[1] = pred4;
predict[2] = pred0;
predict[3] = pred1;
predict += stride;
predict[0] = pred6 = (left[stride*3] + 2 * left[stride*2] +
left[stride] + 2) >> 2;
predict[1] = pred5;
predict[2] = pred4;
predict[3] = pred0;
}
static void
predict_vr_4x4(unsigned char *predict,
int stride)
{
unsigned char *left = predict - 1;
unsigned char *above = predict - stride;
int pred0, pred1, pred2, pred3, pred4, pred5, pred6,
pred7, pred8, pred9;
predict[0] = pred0 = (above[-1] + above[0] + 1) >> 1;
predict[1] = pred1 = (above[ 0] + above[1] + 1) >> 1;
predict[2] = pred2 = (above[ 1] + above[2] + 1) >> 1;
predict[3] = pred3 = (above[ 2] + above[3] + 1) >> 1;
predict += stride;
predict[0] = pred4 = (left[ 0] + 2 * above[-1] +
above[0] + 2) >> 2;
predict[1] = pred5 = (above[-1] + 2 * above[ 0] +
above[1] + 2) >> 2;
predict[2] = pred6 = (above[ 0] + 2 * above[ 1] +
above[2] + 2) >> 2;
predict[3] = pred7 = (above[ 1] + 2 * above[ 2] +
above[3] + 2) >> 2;
predict += stride;
predict[0] = pred8 =
(left[stride] + 2 * left[0] + above[-1] + 2) >> 2;
predict[1] = pred0;
predict[2] = pred1;
predict[3] = pred2;
predict += stride;
predict[0] = pred9 =
(left[stride*2] + 2 * left[stride] + left[0] + 2) >> 2;
predict[1] = pred4;
predict[2] = pred5;
predict[3] = pred6;
}
static void
predict_vl_4x4(unsigned char *predict,
int stride)
{
unsigned char *above = predict - stride;
int pred0, pred1, pred2, pred3, pred4, pred5, pred6,
pred7, pred8, pred9;
predict[0] = pred0 = (above[0] + above[1] + 1) >> 1;
predict[1] = pred1 = (above[1] + above[2] + 1) >> 1;
predict[2] = pred2 = (above[2] + above[3] + 1) >> 1;
predict[3] = pred3 = (above[3] + above[4] + 1) >> 1;
predict += stride;
predict[0] = pred4 = (above[0] + 2 * above[1] +
above[2] + 2) >> 2;
predict[1] = pred5 = (above[1] + 2 * above[2] +
above[3] + 2) >> 2;
predict[2] = pred6 = (above[2] + 2 * above[3] +
above[4] + 2) >> 2;
predict[3] = pred7 = (above[3] + 2 * above[4] +
above[5] + 2) >> 2;
predict += stride;
predict[0] = pred1;
predict[1] = pred2;
predict[2] = pred3;
predict[3] = pred8 = (above[4] + 2 * above[5] +
above[6] + 2) >> 2;
predict += stride;
predict[0] = pred5;
predict[1] = pred6;
predict[2] = pred7;
predict[3] = pred9 = (above[5] + 2 * above[6] +
above[7] + 2) >> 2;
}
static void
predict_hd_4x4(unsigned char *predict,
int stride)
{
unsigned char *left = predict - 1;
unsigned char *above = predict - stride;
int pred0, pred1, pred2, pred3, pred4, pred5, pred6,
pred7, pred8, pred9;
predict[0] = pred0 = (left[ 0] + above[-1] + 1) >> 1;
predict[1] = pred1 = (left[ 0] + 2 * above[-1] +
above[0] + 2) >> 2;
predict[2] = pred2 = (above[-1] + 2 * above[ 0] +
above[1] + 2) >> 2;
predict[3] = pred3 = (above[ 0] + 2 * above[ 1] +
above[2] + 2) >> 2;
predict += stride;
predict[0] = pred4 = (left[stride] + left[0] + 1) >> 1;
predict[1] = pred5 = (left[stride] + 2 * left[0] +
above[-1] + 2) >> 2;
predict[2] = pred0;
predict[3] = pred1;
predict += stride;
predict[0] = pred6 = (left[stride*2] + left[stride] + 1) >> 1;
predict[1] = pred7 = (left[stride*2] + 2 * left[stride] +
left[0] + 2) >> 2;
predict[2] = pred4;
predict[3] = pred5;
predict += stride;
predict[0] = pred8 = (left[stride*3] + left[stride*2] + 1) >> 1;
predict[1] = pred9 = (left[stride*3] + 2 * left[stride*2] +
left[stride] + 2) >> 2;
predict[2] = pred6;
predict[3] = pred7;
}
static void
predict_hu_4x4(unsigned char *predict,
int stride)
{
unsigned char *left = predict - 1;
int pred0, pred1, pred2, pred3, pred4, pred5, pred6;
predict[0] = pred0 = (left[stride*0] +
left[stride*1] + 1) >> 1;
predict[1] = pred1 = (left[stride*0] + 2 * left[stride*1] +
left[stride*2] + 2) >> 2;
predict[2] = pred2 = (left[stride*1] + left[stride*2] + 1) >> 1;
predict[3] = pred3 = (left[stride*1] + 2 * left[stride*2] +
left[stride*3] + 2) >> 2;
predict += stride;
predict[0] = pred2;
predict[1] = pred3;
predict[2] = pred4 = (left[stride*2] + left[stride*3] + 1) >> 1;
predict[3] = pred5 = (left[stride*2] + 2 * left[stride*3] +
left[stride*3] + 2) >> 2;
predict += stride;
predict[0] = pred4;
predict[1] = pred5;
predict[2] = pred6 = left[stride*3];
predict[3] = pred6;
predict += stride;
predict[0] = pred6;
predict[1] = pred6;
predict[2] = pred6;
predict[3] = pred6;
}
static void
predict_h_16x16(unsigned char *predict, int stride)
{
predict_h_nxn(predict, stride, 16);
}
static void
predict_v_16x16(unsigned char *predict, int stride)
{
predict_v_nxn(predict, stride, 16);
}
static void
predict_tm_16x16(unsigned char *predict, int stride)
{
predict_tm_nxn(predict, stride, 16);
}
static void
predict_h_8x8(unsigned char *predict, int stride)
{
predict_h_nxn(predict, stride, 8);
}
static void
predict_v_8x8(unsigned char *predict, int stride)
{
predict_v_nxn(predict, stride, 8);
}
static void
predict_tm_8x8(unsigned char *predict, int stride)
{
predict_tm_nxn(predict, stride, 8);
}
static void
predict_tm_4x4(unsigned char *predict, int stride)
{
predict_tm_nxn(predict, stride, 4);
}
static void
copy_down(unsigned char *recon,
int stride)
{
/* Copy the four pixels above-right of subblock 3 to
* above-right of subblocks 7, 11, and 15
*/
uint32_t tmp, *copy = (void *)(recon + 16 - stride);
stride = stride / sizeof(unsigned int);
tmp = *copy;
copy += stride * 4;
*copy = tmp;
copy += stride * 4;
*copy = tmp;
copy += stride * 4;
*copy = tmp;
}
static void b_pred(unsigned char *predict, int stride, struct mb_info *mbi, short *coeffs) { int i;
static void b_pred（unsigned char *predict、int stride、struct mb_info *mbi、short *coffs）{int i;
copy_down(predict, stride);
copy_down（Predict、Stride）;
for (i = 0; i < 16; i++)
{
unsigned char *b_predict = predict + (i & 3) * 4;
switch (mbi->split.modes[i])
{
case B_DC_PRED:
predict_dc_nxn(b_predict, stride, 4);
break;
case B_TM_PRED:
predict_tm_4x4(b_predict, stride);
break;
case B_VE_PRED:
predict_ve_4x4(b_predict, stride);
break;
case B_HE_PRED:
predict_he_4x4(b_predict, stride);
break;
case B_LD_PRED:
predict_ld_4x4(b_predict, stride);
break;
case B_RD_PRED:
predict_rd_4x4(b_predict, stride);
break;
case B_VR_PRED:
predict_vr_4x4(b_predict, stride);
break;
case B_VL_PRED:
predict_vl_4x4(b_predict, stride);
break;
case B_HD_PRED:
predict_hd_4x4(b_predict, stride);
break;
case B_HU_PRED:
predict_hu_4x4(b_predict, stride);
break;
default:
assert(0);
}
vp8_dixie_idct_add(b_predict, b_predict, stride, coeffs);
coeffs += 16;
if ((i & 3) == 3)
{
predict += stride * 4;
}
}
}
static void
静的ボイド
fixup_dc_coeffs(struct mb_info *mbi, short *coeffs) { short y2[16]; int i;
fixup_dc_coeffs（struct mb_info *mbi、short *coffs）{short y2 [16];int i;
vp8_dixie_walsh(coeffs + 24 * 16, y2);
for (i = 0; i < 16; i++)
coeffs[i*16] = y2[i];
}
static void predict_intra_luma(unsigned char *predict, int stride, struct mb_info *mbi, short *coeffs) { if (mbi->base.y_mode == B_PRED) b_pred(predict, stride, mbi, coeffs); else
static void predict_intra_luma（unsigned char *predict、int stride、struct mb_info *mbi、short *coffs）{if（mbi-> base.y_mode == b_pred）b_pred（予測、ストライド、MBI、係数）;そうしないと
{ int i;
{int i;
switch (mbi->base.y_mode)
{
case DC_PRED:
predict_dc_nxn(predict, stride, 16);
break;
case V_PRED:
predict_v_16x16(predict, stride);
break;
case H_PRED:
predict_h_16x16(predict, stride);
break;
case TM_PRED:
predict_tm_16x16(predict, stride);
break;
default:
assert(0);
}
fixup_dc_coeffs(mbi, coeffs);
fixup_dc_coeffs（MBI、coffs）;
for (i = 0; i < 16; i++)
{
vp8_dixie_idct_add(predict, predict, stride, coeffs);
coeffs += 16;
predict += 4;
if ((i & 3) == 3)
predict += stride * 4 - 16;
}
}
}
static void predict_intra_chroma(unsigned char *predict_u, unsigned char *predict_v, int stride, struct mb_info *mbi, short *coeffs) { int i;
static void predict_intra_chroma（unsigned char *predict_u、unsigned char *predict_v、int stride、struct mb_info *mbi、short *coffs）{int i;
switch (mbi->base.uv_mode)
{
case DC_PRED:
predict_dc_nxn(predict_u, stride, 8);
predict_dc_nxn(predict_v, stride, 8);
break;
case V_PRED:
predict_v_8x8(predict_u, stride);
predict_v_8x8(predict_v, stride);
break;
case H_PRED:
predict_h_8x8(predict_u, stride);
predict_h_8x8(predict_v, stride);
break;
case TM_PRED:
predict_tm_8x8(predict_u, stride);
predict_tm_8x8(predict_v, stride);
break;
default:
assert(0);
}
coeffs += 16 * 16;
for (i = 16; i < 20; i++)
{
vp8_dixie_idct_add(predict_u, predict_u, stride, coeffs);
coeffs += 16;
predict_u += 4;
if (i & 1)
predict_u += stride * 4 - 8;
}
for (i = 20; i < 24; i++)
{
vp8_dixie_idct_add(predict_v, predict_v, stride, coeffs);
coeffs += 16;
predict_v += 4;
if (i & 1)
predict_v += stride * 4 - 8;
}
}
static void
sixtap_horiz(unsigned char *output,
int output_stride,
const unsigned char *reference,
int reference_stride,
int cols,
int rows,
const filter_t filter
)
{
int r, c, temp;
for (r = 0; r < rows; r++)
{
for (c = 0; c < cols; c++)
{
temp = (reference[-2] * filter[0]) +
(reference[-1] * filter[1]) +
(reference[ 0] * filter[2]) +
(reference[ 1] * filter[3]) +
(reference[ 2] * filter[4]) +
(reference[ 3] * filter[5]) +
64;
temp >>= 7;
output[c] = CLAMP_255(temp);
reference++;
}
reference += reference_stride - cols;
output += output_stride;
}
}
static void
sixtap_vert(unsigned char *output,
int output_stride,
const unsigned char *reference,
int reference_stride,
int cols,
int rows,
const filter_t filter
)
{
int r, c, temp;
for (r = 0; r < rows; r++)
{
for (c = 0; c < cols; c++)
{
temp = (reference[-2*reference_stride] * filter[0]) +
(reference[-1*reference_stride] * filter[1]) +
(reference[ 0*reference_stride] * filter[2]) +
(reference[ 1*reference_stride] * filter[3]) +
(reference[ 2*reference_stride] * filter[4]) +
(reference[ 3*reference_stride] * filter[5]) +
64;
temp >>= 7;
output[c] = CLAMP_255(temp);
reference++;
}
reference += reference_stride - cols;
output += output_stride;
}
}
static void
sixtap_2d(unsigned char *output,
int output_stride,
const unsigned char *reference,
int reference_stride,
int cols,
int rows,
int mx,
int my,
const filter_t filters[8]
)
{
DECLARE_ALIGNED(16, unsigned char, temp[16*(16+5)]);
sixtap_horiz(temp, 16,
reference - 2 * reference_stride, reference_stride,
cols, rows + 5, filters[mx]);
sixtap_vert(output, output_stride,
temp + 2 * 16, 16,
cols, rows, filters[my]);
}
struct img_index
{
unsigned char *y, *u, *v;
int stride, uv_stride;
};
static const unsigned char * filter_block(unsigned char *output, const unsigned char *reference, int stride, const union mv *mv, const filter_t filters[8]) { int mx, my;
static const unsigned char *filter_block（unsigned char *output、const unsigned char *reference、int stride、const Union mv *mv、const filter_t filters [8]）{int mx、my;
/* Handle 0,0 as a special case. TODO: Does this make it any
* faster?
*/
if (!mv->raw)
return reference;
mx = mv->d.x & 7;
my = mv->d.y & 7;
reference += ((mv->d.y >> 3) * stride) + (mv->d.x >> 3);
if (mx | my)
{
sixtap_2d(output, stride, reference, stride, 4, 4, mx, my,
filters);
reference = output;
}
return reference; }
リファレンスを返す;}
static void
recon_1_block(unsigned char *output,
const unsigned char *reference,
int stride,
const union mv *mv,
const filter_t filters[8],
short *coeffs,
struct mb_info *mbi,
int b
)
{
const unsigned char *predict;
predict = filter_block(output, reference, stride, mv, filters);
vp8_dixie_idct_add(output, predict, stride, coeffs + 16 * b);
}
static mv_t
calculate_chroma_splitmv(struct mb_info *mbi,
int b,
int full_pixel)
{
int temp;
union mv mv;
temp = mbi->split.mvs[b].d.x +
mbi->split.mvs[b+1].d.x +
mbi->split.mvs[b+4].d.x +
mbi->split.mvs[b+5].d.x;
if (temp < 0)
temp -= 4;
else
temp += 4;
mv.d.x = temp / 8;
temp = mbi->split.mvs[b].d.y +
mbi->split.mvs[b+1].d.y +
mbi->split.mvs[b+4].d.y +
mbi->split.mvs[b+5].d.y;
if (temp < 0)
temp -= 4;
else
temp += 4;
mv.d.y = temp / 8;
if (full_pixel)
{
mv.d.x &= ~7;
mv.d.y &= ~7;
}
return mv; }
MVを返します。}
/* Note: We rely on the reconstructed border having the same stride
* as the reference buffer because the filter_block can't adjust the
* stride with its return value, only the reference pointer.
*/
static void
build_mc_border(unsigned char *dst,
const unsigned char *src,
int stride,
int x,
int y,
int b_w,
int b_h,
int w,
int h
)
{
const unsigned char *ref_row;
/* Get a pointer to the start of the real data for this row */
ref_row = src - x - y * stride;
if (y >= h)
ref_row += (h - 1) * stride;
else if (y > 0)
ref_row += y * stride;
do { int left, right = 0, copy;
{int左、右= 0、copy;
left = x < 0 ? -x : 0;
if (left > b_w) left = b_w;
if（left> b_w）left = b_w;
if (x + b_w > w)
right = x + b_w - w;
if (right > b_w) right = b_w;
if（right> b_w）right = b_w;
copy = b_w - left - right;
if (left) memset(dst, ref_row[0], left);
if（左）memset（dst、ref_row [0]、左）;
if (copy)
memcpy(dst + left, ref_row + x + left, copy);
if (right)
memset(dst + left + copy, ref_row[w-1], right);
dst += stride;
y++;
if (y < h && y > 0)
ref_row += stride;
}
while (--b_h);
}
static void
recon_1_edge_block(unsigned char *output,
unsigned char *emul_block,
const unsigned char *reference,
int stride,
const union mv *mv,
const filter_t filters[8],
short *coeffs,
struct mb_info *mbi,
int x,
int y,
int w,
int h,
int start_b
)
{
const unsigned char *predict;
int b = start_b;
const int b_w = 4;
const int b_h = 4;
x += mv->d.x >> 3;
y += mv->d.y >> 3;
/* Need two pixels left/above, 3 right/below for 6-tap */
if (x < 2 || x + b_w - 1 + 3 >= w || y < 2 ||
y + b_h - 1 + 3 >= h)
{
reference += (mv->d.x >> 3) + (mv->d.y >> 3) * stride;
build_mc_border(emul_block,
reference - 2 - 2 * stride, stride,
x - 2, y - 2, b_w + 5, b_h + 5, w, h);
reference = emul_block + 2 * stride + 2;
reference -= (mv->d.x >> 3) + (mv->d.y >> 3) * stride;
}
predict = filter_block(output, reference, stride, mv, filters);
vp8_dixie_idct_add(output, predict, stride, coeffs + 16 * b);
}
static void
predict_inter_emulated_edge(struct vp8_decoder_ctx *ctx,
struct img_index *img,
short *coeffs,
struct mb_info *mbi,
int mb_col,
int mb_row)
{
/* TODO: Move this into its own buffer. This only works because
* we still have a border allocated.
*/
unsigned char *emul_block = ctx->frame_strg[0].img.img_data;
unsigned char *reference;
unsigned char *output;
ptrdiff_t reference_offset;
int w, h, x, y, b;
union mv chroma_mv[4];
unsigned char *u = img->u, *v = img->v;
int full_pixel = ctx->frame_hdr.version == 3;
x = mb_col * 16;
y = mb_row * 16;
w = ctx->mb_cols * 16;
h = ctx->mb_rows * 16;
output = img->y;
reference_offset = ctx->ref_frame_offsets[mbi->base.ref_frame];
reference = output + reference_offset;
if (mbi->base.y_mode != SPLITMV)
{
union mv uvmv;
uvmv = mbi->base.mv;
uvmv.d.x = (uvmv.d.x + 1 + (uvmv.d.x >> 31) * 2) / 2;
uvmv.d.y = (uvmv.d.y + 1 + (uvmv.d.y >> 31) * 2) / 2;
if (full_pixel)
{
uvmv.d.x &= ~7;
uvmv.d.y &= ~7;
}
chroma_mv[0] = uvmv;
chroma_mv[1] = uvmv;
chroma_mv[2] = uvmv;
chroma_mv[3] = uvmv;
}
else
{
chroma_mv[0] = calculate_chroma_splitmv(mbi, 0, full_pixel);
chroma_mv[1] = calculate_chroma_splitmv(mbi, 2, full_pixel);
chroma_mv[2] = calculate_chroma_splitmv(mbi, 8, full_pixel);
chroma_mv[3] = calculate_chroma_splitmv(mbi, 10, full_pixel);
}
/* Luma */
for (b = 0; b < 16; b++)
{
union mv *ymv;
if (mbi->base.y_mode != SPLITMV)
ymv = &mbi->base.mv;
else
ymv = mbi->split.mvs + b;
recon_1_edge_block(output, emul_block, reference, img->stride, ymv, ctx->subpixel_filters, coeffs, mbi, x, y, w, h, b);
Recon_1_edge_block（output、emul_block、reference、img-> stride、ymv、ctx-> subpixel_filters、coeffs、mbi、x、y、w、h、b）;
x += 4;
output += 4;
reference += 4;
if ((b & 3) == 3)
{
x -= 16;
y += 4;
output += 4 * img->stride - 16;
reference += 4 * img->stride - 16;
}
}
x = mb_col * 16;
y = mb_row * 16;
/* Chroma */
x >>= 1;
y >>= 1;
w >>= 1;
h >>= 1;
for (b = 0; b < 4; b++)
{
recon_1_edge_block(u, emul_block, u + reference_offset,
img->uv_stride,
&chroma_mv[b], ctx->subpixel_filters,
coeffs, mbi, x, y, w, h, b + 16);
recon_1_edge_block(v, emul_block, v + reference_offset,
img->uv_stride,
&chroma_mv[b], ctx->subpixel_filters,
coeffs, mbi, x, y, w, h, b + 20);
u += 4;
v += 4;
x += 4;
if (b & 1)
{
x -= 8;
y += 4;
u += 4 * img->uv_stride - 8;
v += 4 * img->uv_stride - 8;
}
}
}
}
static void predict_inter(struct vp8_decoder_ctx *ctx, struct img_index *img, short *coeffs, struct mb_info *mbi)
static void predict_inter（struct vp8_decoder_ctx *ctx、struct img_index *img、short *coffs、struct mb_info *mbi）
{
unsigned char *y = img->y;
unsigned char *u = img->u;
unsigned char *v = img->v;
ptrdiff_t reference_offset;
union mv chroma_mv[4];
int full_pixel = ctx->frame_hdr.version == 3;
int b;
if (mbi->base.y_mode != SPLITMV)
{
union mv uvmv;
uvmv = mbi->base.mv;
uvmv.d.x = (uvmv.d.x + 1 + (uvmv.d.x >> 31) * 2) / 2;
uvmv.d.y = (uvmv.d.y + 1 + (uvmv.d.y >> 31) * 2) / 2;
if (full_pixel)
{
uvmv.d.x &= ~7;
uvmv.d.y &= ~7;
}
chroma_mv[0] =
chroma_mv[1] =
chroma_mv[2] =
chroma_mv[3] = uvmv;
}
else
{
chroma_mv[0] = calculate_chroma_splitmv(mbi, 0, full_pixel);
chroma_mv[1] = calculate_chroma_splitmv(mbi, 2, full_pixel);
chroma_mv[2] = calculate_chroma_splitmv(mbi, 8, full_pixel);
chroma_mv[3] = calculate_chroma_splitmv(mbi, 10, full_pixel);
}
reference_offset = ctx->ref_frame_offsets[mbi->base.ref_frame];
for (b = 0; b < 16; b++)
{
union mv *ymv;
if (mbi->base.y_mode != SPLITMV)
ymv = &mbi->base.mv;
else
ymv = mbi->split.mvs + b;
recon_1_block(y, y + reference_offset, img->stride,
ymv, ctx->subpixel_filters, coeffs, mbi, b);
y += 4;
if ((b & 3) == 3)
y += 4 * img->stride - 16;
}
for (b = 0; b < 4; b++)
{
recon_1_block(u, u + reference_offset,
img->uv_stride, &chroma_mv[b],
ctx->subpixel_filters, coeffs, mbi, b + 16);
recon_1_block(v, v + reference_offset,
img->uv_stride, &chroma_mv[b],
ctx->subpixel_filters, coeffs, mbi, b + 20);
u += 4;
v += 4;
if (b & 1)
{
u += 4 * img->uv_stride - 8;
v += 4 * img->uv_stride - 8;
}
}
}
void
vp8_dixie_release_ref_frame(struct ref_cnt_img *rcimg)
{
if (rcimg)
{
assert(rcimg->ref_cnt);
rcimg->ref_cnt--;
}
}
struct ref_cnt_img *
vp8_dixie_ref_frame(struct ref_cnt_img *rcimg)
{
rcimg->ref_cnt++;
return rcimg;
}
struct ref_cnt_img * vp8_dixie_find_free_ref_frame(struct ref_cnt_img *frames) { int i;
struct ref_cnt_img * vp8_dixie_find_free_ref_frame（struct ref_cnt_img * frames）{int i;
for (i = 0; i < NUM_REF_FRAMES; i++)
if (frames[i].ref_cnt == 0)
{
frames[i].ref_cnt = 1;
return &frames[i];
}
assert(0); return NULL; }
assert（0）;nullを返します。}
static void
fixup_left(unsigned char *predict,
int width,
int stride,
unsigned int row,
enum prediction_mode mode)
{
/* The left column of out-of-frame pixels is taken to be 129,
* unless we're doing DC_PRED, in which case we duplicate the
* above row, unless this is also row 0, in which case we use
* 129.
*/
unsigned char *left = predict - 1;
int i;
if (mode == DC_PRED && row)
{
unsigned char *above = predict - stride;
for (i = 0; i < width; i++)
{
*left = above[i];
left += stride;
}
}
else
{
/* Need to re-set the above row, in case the above MB was
* DC_PRED.
*/
left -= stride;
for (i = -1; i < width; i++)
{
*left = 129;
left += stride;
}
}
}
static void
fixup_above(unsigned char *predict,
int width,
int stride,
unsigned int col,
enum prediction_mode mode)
{
/* The above row of out-of-frame pixels is taken to be 127,
* unless we're doing DC_PRED, in which case we duplicate the
* left col, unless this is also col 0, in which case we use
* 127.
*/
unsigned char *above = predict - stride;
int i;
if (mode == DC_PRED && col)
{
unsigned char *left = predict - 1;
for (i = 0; i < width; i++)
{
above[i] = *left;
left += stride;
}
}
else
/* Need to re-set the left col, in case the last MB was
* DC_PRED.
*/
memset(above - 1, 127, width + 1);
memset(above + width, 127, 4); // for above-right subblock modes
}
void vp8_dixie_predict_init(struct vp8_decoder_ctx *ctx) {
void vp8_dixie_predict_init（struct vp8_decoder_ctx *ctx）{
int i; unsigned char *this_frame_base;
int i;unsigned char *this_frame_base;
if (ctx->frame_hdr.frame_size_updated)
{
for (i = 0; i < NUM_REF_FRAMES; i++)
{
unsigned int w = ctx->mb_cols * 16 + BORDER_PIXELS * 2;
unsigned int h = ctx->mb_rows * 16 + BORDER_PIXELS * 2;
vpx_img_free(&ctx->frame_strg[i].img);
ctx->frame_strg[i].ref_cnt = 0;
ctx->ref_frames[i] = NULL;
if (!vpx_img_alloc(&ctx->frame_strg[i].img, IMG_FMT_I420, w, h, 16)) vpx_internal_error(&ctx->error, VPX_CODEC_MEM_ERROR, "Failed to allocate %dx%d" " framebuffer", w, h);
if（！vpx_img_alloc（＆ctx-> frame_strg [i] .img、img_fmt_i420、w、h、16））vpx_internal_error（＆ctx->エラー、vpx_codec_mem_error、 ";
vpx_img_set_rect(&ctx->frame_strg[i].img, BORDER_PIXELS,
BORDER_PIXELS, ctx->frame_hdr.kf.w,
ctx->frame_hdr.kf.h);
}
}
if (ctx->frame_hdr.version)
ctx->subpixel_filters = bilinear_filters;
else
ctx->subpixel_filters = sixtap_filters;
}
/* Find a free framebuffer to predict into */
if (ctx->ref_frames[CURRENT_FRAME])
vp8_dixie_release_ref_frame(ctx->ref_frames[CURRENT_FRAME]);
ctx->ref_frames[CURRENT_FRAME] =
vp8_dixie_find_free_ref_frame(ctx->frame_strg);
this_frame_base = ctx->ref_frames[CURRENT_FRAME]->img.img_data;
/* Calculate offsets to the other reference frames */
for (i = 0; i < NUM_REF_FRAMES; i++)
{
struct ref_cnt_img *ref = ctx->ref_frames[i];
ctx->ref_frame_offsets[i] =
ref ? ref->img.img_data - this_frame_base : 0;
}
/* TODO: No need to do this on every frame... */
}
void vp8_dixie_predict_destroy(struct vp8_decoder_ctx *ctx) { int i;
void vp8_dixie_predict_destroy（struct vp8_decoder_ctx *ctx）{int i;
for (i = 0; i < NUM_REF_FRAMES; i++)
{
vpx_img_free(&ctx->frame_strg[i].img);
ctx->frame_strg[i].ref_cnt = 0;
ctx->ref_frames[i] = NULL;
}
}
void
vp8_dixie_predict_process_row(struct vp8_decoder_ctx *ctx,
unsigned int row,
unsigned int start_col,
unsigned int num_cols)
{
struct img_index img;
struct mb_info *mbi;
unsigned int col;
short *coeffs;
/* Adjust pointers based on row, start_col */
img.stride =
ctx->ref_frames[CURRENT_FRAME]->img.stride[PLANE_Y];
img.uv_stride =
ctx->ref_frames[CURRENT_FRAME]->img.stride[PLANE_U];
img.y = ctx->ref_frames[CURRENT_FRAME]->img.planes[PLANE_Y];
img.u = ctx->ref_frames[CURRENT_FRAME]->img.planes[PLANE_U];
img.v = ctx->ref_frames[CURRENT_FRAME]->img.planes[PLANE_V];
img.y += (img.stride * row + start_col) * 16;
img.u += (img.uv_stride * row + start_col) * 8;
img.v += (img.uv_stride * row + start_col) * 8;
mbi = ctx->mb_info_rows[row] + start_col;
coeffs = ctx->tokens[row &
(ctx->token_hdr.partitions - 1)].coeffs +
25 * 16 * start_col;
/* Fix up the out-of-frame pixels */
if (start_col == 0)
{
fixup_left(img.y, 16, img.stride, row, mbi->base.y_mode);
fixup_left(img.u, 8, img.uv_stride, row, mbi->base.uv_mode);
fixup_left(img.v, 8, img.uv_stride, row, mbi->base.uv_mode);
if (row == 0)
*(img.y - img.stride - 1) = 127;
}
for (col = start_col; col < start_col + num_cols; col++)
{
if (row == 0)
{
fixup_above(img.y, 16, img.stride, col,
mbi->base.y_mode);
fixup_above(img.u, 8, img.uv_stride, col,
mbi->base.uv_mode);
fixup_above(img.v, 8, img.uv_stride, col,
mbi->base.uv_mode);
}
if (mbi->base.y_mode <= B_PRED)
{
predict_intra_luma(img.y, img.stride, mbi, coeffs);
predict_intra_chroma(img.u, img.v, img.uv_stride, mbi,
coeffs);
}
else
{
if (mbi->base.y_mode != SPLITMV) // && != BPRED
fixup_dc_coeffs(mbi, coeffs);
if (mbi->base.need_mc_border) predict_inter_emulated_edge(ctx, &img, coeffs, mbi, col, row); else predict_inter(ctx, &img, coeffs, mbi); }
if（mbi-> base.need_mc_border）preprid_inter_emulated_edge（ctx、＆img、coeffs、mbi、col、row）;else_inter（ctx、＆img、coeffs、mbi）;}
/* Advance to the next macroblock */
mbi++;
img.y += 16;
img.u += 8;
img.v += 8;
coeffs += 25 * 16;
}
if (col == ctx->mb_cols)
{
/* Extend the last row by four pixels for intra-prediction.
* This will be propagated later by copy_down.
*/
uint32_t *extend = (uint32_t *)(img.y + 15 * img.stride);
uint32_t val = 0x01010101 * img.y[-1 + 15 * img.stride];
*extend = val;
}
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef PREDICT_H
#define PREDICT_H
void vp8_dixie_predict_init(struct vp8_decoder_ctx *ctx);
void vp8_dixie_predict_init（struct vp8_decoder_ctx *ctx）;
void vp8_dixie_predict_destroy(struct vp8_decoder_ctx *ctx);
void vp8_dixie_predict_destroy（struct vp8_decoder_ctx *ctx）;
void
vp8_dixie_predict_process_row(struct vp8_decoder_ctx *ctx,
unsigned int row,
unsigned int start_col,
unsigned int num_cols);
void vp8_dixie_release_ref_frame(struct ref_cnt_img *rcimg);
void vp8_dixie_release_ref_frame（struct ref_cnt_img *rcimg）;
struct ref_cnt_img *
vp8_dixie_ref_frame(struct ref_cnt_img *rcimg);
struct ref_cnt_img *
vp8_dixie_find_free_ref_frame(struct ref_cnt_img *frames);
#endif
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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_codec_internal.h"
#include "dixie.h"
#include "tokens.h"
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
enum
{
EOB_CONTEXT_NODE,
ZERO_CONTEXT_NODE,
ONE_CONTEXT_NODE,
LOW_VAL_CONTEXT_NODE,
TWO_CONTEXT_NODE,
THREE_CONTEXT_NODE,
HIGH_LOW_CONTEXT_NODE,
CAT_ONE_CONTEXT_NODE,
CAT_THREEFOUR_CONTEXT_NODE,
CAT_THREE_CONTEXT_NODE,
CAT_FIVE_CONTEXT_NODE
};
enum
{
ZERO_TOKEN,
ONE_TOKEN,
TWO_TOKEN,
THREE_TOKEN,
FOUR_TOKEN,
DCT_VAL_CATEGORY1,
DCT_VAL_CATEGORY2,
DCT_VAL_CATEGORY3,
DCT_VAL_CATEGORY4,
DCT_VAL_CATEGORY5,
DCT_VAL_CATEGORY6,
DCT_EOB_TOKEN,
MAX_ENTROPY_TOKENS
};
struct extrabits
{
short min_val;
short length;
unsigned char probs[12];
};
static const unsigned int left_context_index[25] =
{
0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
4, 4, 5, 5, 6, 6, 7, 7, 8
};
static const unsigned int above_context_index[25] =
{
0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,
4, 5, 4, 5, 6, 7, 6, 7, 8
};
#define X(n) ((n) * PREV_COEFF_CONTEXTS * ENTROPY_NODES)
static const unsigned int bands_x[16] =
{
X(0), X(1), X(2), X(3), X(6), X(4), X(5), X(6),
X(6), X(6), X(6), X(6), X(6), X(6), X(6), X(7)
};
#undef X
static const struct extrabits extrabits[MAX_ENTROPY_TOKENS] =
{
{ 0, -1, { 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, //ZERO_TOKEN
{ 1, 0, { 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, //ONE_TOKEN
{ 2, 0, { 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, //TWO_TOKEN
{ 3, 0, { 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, //THREE_TOKEN
{ 4, 0, { 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, //FOUR_TOKEN
{ 5, 0, {159, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, //DCT_VAL_CATEGORY1
{ 7, 1, {145, 165, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, //DCT_VAL_CATEGORY2
{11, 2, {140, 148, 173, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, //DCT_VAL_CATEGORY3
{19, 3, {135, 140, 155, 176, 0, 0,
0, 0, 0, 0, 0, 0 } }, //DCT_VAL_CATEGORY4
{35, 4, {130, 134, 141, 157, 180, 0,
0, 0, 0, 0, 0, 0 } }, //DCT_VAL_CATEGORY5
{67, 10, {129, 130, 133, 140, 153, 177,
196, 230, 243, 254, 254, 0 } }, //DCT_VAL_CATEGORY6
{ 0, -1, { 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 } }, // EOB TOKEN
};
static const unsigned int zigzag[16] = { 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15 };
static const unsigned int zigzag [16] = {0、1、4、8、5、2、3、6、9、12、13、10、7、11、14、15};
#define DECODE_AND_APPLYSIGN(value_to_sign) \
v = (bool_get_bit(bool) ? -value_to_sign \
: value_to_sign) * dqf[!!c];
#define DECODE_AND_BRANCH_IF_ZERO(probability,branch) \
if (!bool_get(bool, probability)) goto branch;
#define DECODE_AND_LOOP_IF_ZERO(probability,branch) \
if (!bool_get(bool, probability)) \
{ \
prob = type_probs; \
if (c<15) {\
++c; \
prob += bands_x[c]; \
goto branch; \
}\
else \
goto BLOCK_FINISHED; /* for malformed input */\
}
#define DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val) \
DECODE_AND_APPLYSIGN(val) \
prob = type_probs + (ENTROPY_NODES*2); \
if (c < 15){\
b_tokens[zigzag[c]] = v; \
++c; \
goto DO_WHILE; }\
b_tokens[zigzag[15]] = v; \
goto BLOCK_FINISHED;
#define DECODE_EXTRABIT_AND_ADJUST_VAL(t,bits_count)\
val += bool_get(bool, extrabits[t].probs[bits_count]) << \
bits_count;
static int
decode_mb_tokens(struct bool_decoder *bool,
token_entropy_ctx_t left,
token_entropy_ctx_t above,
short *tokens,
enum prediction_mode mode,
coeff_probs_table_t probs,
short factor[TOKEN_BLOCK_TYPES][2])
{
int i, stop, type;
int c, t, v;
int val, bits_count;
int eob_mask;
short *b_tokens; // tokens for this block
unsigned char *type_probs; // probabilities for this block type
unsigned char *prob;
short *dqf;
eob_mask = 0;
EOB_MASK = 0;
if (mode != B_PRED && mode != SPLITMV)
{
i = 24;
stop = 24;
type = 1;
b_tokens = tokens + 24 * 16;
dqf = factor[TOKEN_BLOCK_Y2];
}
else
{
i = 0;
stop = 16;
type = 3;
b_tokens = tokens;
dqf = factor[TOKEN_BLOCK_Y1];
}
/* Save a pointer to the coefficient probs for the current type.
* Need to repeat this whenever type changes.
*/
type_probs = probs[type][0][0];
BLOCK_LOOP:
t = left[left_context_index[i]] + above[above_context_index[i]];
c = !type; /* all blocks start at 0 except type 0, which starts
* at 1. */
prob = type_probs;
prob += t * ENTROPY_NODES;
DO_WHILE:
prob += bands_x[c];
DECODE_AND_BRANCH_IF_ZERO(prob[EOB_CONTEXT_NODE],
BLOCK_FINISHED);
CHECK_0_:
DECODE_AND_LOOP_IF_ZERO(prob[ZERO_CONTEXT_NODE], CHECK_0_);
DECODE_AND_BRANCH_IF_ZERO(prob[ONE_CONTEXT_NODE],
ONE_CONTEXT_NODE_0_);
DECODE_AND_BRANCH_IF_ZERO(prob[LOW_VAL_CONTEXT_NODE],
LOW_VAL_CONTEXT_NODE_0_);
DECODE_AND_BRANCH_IF_ZERO(prob[HIGH_LOW_CONTEXT_NODE],
HIGH_LOW_CONTEXT_NODE_0_);
DECODE_AND_BRANCH_IF_ZERO(prob[CAT_THREEFOUR_CONTEXT_NODE],
CAT_THREEFOUR_CONTEXT_NODE_0_);
DECODE_AND_BRANCH_IF_ZERO(prob[CAT_FIVE_CONTEXT_NODE],
CAT_FIVE_CONTEXT_NODE_0_);
val = extrabits[DCT_VAL_CATEGORY6].min_val;
bits_count = extrabits[DCT_VAL_CATEGORY6].length;
do
{
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY6,
bits_count);
bits_count --;
}
while (bits_count >= 0);
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
decode_sign_write_coeff_and_check_exit（val）;
CAT_FIVE_CONTEXT_NODE_0_:
val = extrabits[DCT_VAL_CATEGORY5].min_val;
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 4);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 3);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 2);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 1);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY5, 0);
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
CAT_THREEFOUR_CONTEXT_NODE_0_:
DECODE_AND_BRANCH_IF_ZERO(prob[CAT_THREE_CONTEXT_NODE],
CAT_THREE_CONTEXT_NODE_0_);
val = extrabits[DCT_VAL_CATEGORY4].min_val;
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 3);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 2);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 1);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY4, 0);
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
CAT_THREE_CONTEXT_NODE_0_:
val = extrabits[DCT_VAL_CATEGORY3].min_val;
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 2);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 1);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY3, 0);
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
HIGH_LOW_CONTEXT_NODE_0_: DECODE_AND_BRANCH_IF_ZERO(prob[CAT_ONE_CONTEXT_NODE], CAT_ONE_CONTEXT_NODE_0_);
high_low_context_node_0_：decode_and_branch_if_zero（prob [cat_one_context_node]、cat_one_context_node_0_）;
val = extrabits[DCT_VAL_CATEGORY2].min_val;
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY2, 1);
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY2, 0);
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
CAT_ONE_CONTEXT_NODE_0_:
val = extrabits[DCT_VAL_CATEGORY1].min_val;
DECODE_EXTRABIT_AND_ADJUST_VAL(DCT_VAL_CATEGORY1, 0);
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(val);
LOW_VAL_CONTEXT_NODE_0_:
DECODE_AND_BRANCH_IF_ZERO(prob[TWO_CONTEXT_NODE],
TWO_CONTEXT_NODE_0_);
DECODE_AND_BRANCH_IF_ZERO(prob[THREE_CONTEXT_NODE],
THREE_CONTEXT_NODE_0_);
DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(4);
THREE_CONTEXT_NODE_0_: DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(3);
Three_context_node_0_：decode_sign_write_coeff_and_check_exit（3）;
TWO_CONTEXT_NODE_0_: DECODE_SIGN_WRITE_COEFF_AND_CHECK_EXIT(2);
Two_context_node_0_：decode_sign_write_coeff_and_check_exit（2）;
ONE_CONTEXT_NODE_0_:
DECODE_AND_APPLYSIGN(1);
prob = type_probs + ENTROPY_NODES;
if (c < 15)
{
b_tokens[zigzag[c]] = v;
++c;
goto DO_WHILE;
}
b_tokens[zigzag[15]] = v;
BLOCK_FINISHED:
eob_mask |= (c > 1) << i;
t = (c != !type); // any non-zero data?
eob_mask |= t << 31;
left[left_context_index[i]] = above[above_context_index[i]] = t;
b_tokens += 16;
i++;
if (i < stop) goto BLOCK_LOOP;
if（i <stop）goto block_loop;
if (i == 25)
{
type = 0;
i = 0;
stop = 16;
type_probs = probs[type][0][0];
b_tokens = tokens;
dqf = factor[TOKEN_BLOCK_Y1];
goto BLOCK_LOOP;
}
if (i == 16)
{
type = 2;
type_probs = probs[type][0][0];
stop = 24;
dqf = factor[TOKEN_BLOCK_UV];
goto BLOCK_LOOP;
}
return eob_mask; }
eob_maskを返します。}
static void
reset_row_context(token_entropy_ctx_t *left)
{
memset(left, 0, sizeof(*left));
}
static void
reset_above_context(token_entropy_ctx_t *above, unsigned int cols)
{
memset(above, 0, cols * sizeof(*above));
}
static void
reset_mb_context(token_entropy_ctx_t *left,
token_entropy_ctx_t *above,
enum prediction_mode mode)
{
/* Reset the macroblock context on the left and right. We have
* to preserve the context of the second order block if this mode
* would not have updated it.
*/
memset(left, 0, sizeof((*left)[0]) * 8);
memset(above, 0, sizeof((*above)[0]) * 8);
if (mode != B_PRED && mode != SPLITMV)
{
(*left)[8] = 0;
(*above)[8] = 0;
}
}
void
vp8_dixie_tokens_process_row(struct vp8_decoder_ctx *ctx,
unsigned int partition,
unsigned int row,
unsigned int start_col,
unsigned int num_cols)
{
struct token_decoder *tokens = &ctx->tokens[partition];
short coeffs = tokens->coeffs + 25 * 16 * start_col;
unsigned int col;
token_entropy_ctx_t *above = ctx->above_token_entropy_ctx
+ start_col;
token_entropy_ctx_t *left = &tokens->left_token_entropy_ctx;
struct mb_info *mbi = ctx->mb_info_rows[row] + start_col;
if (row == 0)
reset_above_context(above, num_cols);
if (start_col == 0)
reset_row_context(left);
for (col = start_col; col < start_col + num_cols; col++)
{
memset(coeffs, 0, 25 * 16 * sizeof(short));
if (mbi->base.skip_coeff)
{
reset_mb_context(left, above, mbi->base.y_mode);
mbi->base.eob_mask = 0;
}
else
{
struct dequant_factors *dqf;
dqf = ctx->dequant_factors + mbi->base.segment_id;
mbi->base.eob_mask =
decode_mb_tokens(&tokens->bool,
*left, *above,
coeffs,
mbi->base.y_mode,
ctx->entropy_hdr.coeff_probs,
dqf->factor);
}
above++;
mbi++;
coeffs += 25 * 16;
}
}
void
vp8_dixie_tokens_init(struct vp8_decoder_ctx *ctx)
{
unsigned int partitions = ctx->token_hdr.partitions;
if (ctx->frame_hdr.frame_size_updated)
{
unsigned int i;
unsigned int coeff_row_sz =
ctx->mb_cols * 25 * 16 * sizeof(short);
for (i = 0; i < partitions; i++)
{
free(ctx->tokens[i].coeffs);
ctx->tokens[i].coeffs = memalign(16, coeff_row_sz);
if (!ctx->tokens[i].coeffs)
vpx_internal_error(&ctx->error, VPX_CODEC_MEM_ERROR,
NULL);
}
free(ctx->above_token_entropy_ctx);
ctx->above_token_entropy_ctx =
calloc(ctx->mb_cols,
sizeof(*ctx->above_token_entropy_ctx));
if (!ctx->above_token_entropy_ctx)
vpx_internal_error(&ctx->error,
VPX_CODEC_MEM_ERROR, NULL);
}
}
void vp8_dixie_tokens_destroy(struct vp8_decoder_ctx *ctx) { int i;
void vp8_dixie_tokens_destroy（struct vp8_decoder_ctx *ctx）{int i;
for (i = 0; i < MAX_PARTITIONS; i++)
free(ctx->tokens[i].coeffs);
free(ctx->above_token_entropy_ctx);
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef TOKENS_H
#define TOKENS_H
void vp8_dixie_tokens_init(struct vp8_decoder_ctx *ctx);
void vp8_dixie_tokens_init（struct vp8_decoder_ctx *ctx）;
void vp8_dixie_tokens_destroy(struct vp8_decoder_ctx *ctx);
void vp8_dixie_tokens_destroy（struct vp8_decoder_ctx *ctx）;
void
vp8_dixie_tokens_process_row(struct vp8_decoder_ctx *ctx,
unsigned int partition,
unsigned int row,
unsigned int start_col,
unsigned int num_cols);
#endif
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
static const
unsigned char k_coeff_entropy_update_probs[BLOCK_TYPES][COEFF_BANDS]
[PREV_COEFF_CONTEXTS]
[ENTROPY_NODES] =
{
{
{
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{176, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{223, 241, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{249, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 244, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{234, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 246, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{239, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{251, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{251, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 254, 253, 255, 254, 255, 255, 255, 255, 255, 255},
{250, 255, 254, 255, 254, 255, 255, 255, 255, 255, 255},
{254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
},
{
{
{217, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{225, 252, 241, 253, 255, 255, 254, 255, 255, 255, 255},
{234, 250, 241, 250, 253, 255, 253, 254, 255, 255, 255},
},
{
{255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{223, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{238, 253, 254, 254, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{249, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{247, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 254, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
},
{
{
{186, 251, 250, 255, 255, 255, 255, 255, 255, 255, 255},
{234, 251, 244, 254, 255, 255, 255, 255, 255, 255, 255},
{251, 251, 243, 253, 254, 255, 254, 255, 255, 255, 255},
},
{
{255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{236, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{251, 253, 253, 254, 254, 255, 255, 255, 255, 255, 255},
},
{
{255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
},
{
{
{248, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{250, 254, 252, 254, 255, 255, 255, 255, 255, 255, 255},
{248, 254, 249, 253, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{246, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{252, 254, 251, 254, 254, 255, 255, 255, 255, 255, 255},
},
{
{255, 254, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{248, 254, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{253, 255, 254, 254, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 251, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{245, 251, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{253, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 251, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{252, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{249, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 255, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
{
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
},
},
};
static const unsigned char k_default_y_mode_probs [] = { 112, 86, 140, 37};
static const unsigned char k_default_y_mode_probs [] = {112、86、140、37};
static const unsigned char k_default_uv_mode_probs [] = { 162, 101, 204};
static const unsigned char k_default_uv_mode_probs [] = {162、101、204};
static const
unsigned char k_default_coeff_probs [BLOCK_TYPES][COEFF_BANDS]
[PREV_COEFF_CONTEXTS][ENTROPY_NODES] =
{
{ /* block type 0 */
{ /* coeff band 0 */
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
},
{ /* coeff band 1 */
{ 253, 136, 254, 255, 228, 219, 128, 128, 128, 128, 128},
{ 189, 129, 242, 255, 227, 213, 255, 219, 128, 128, 128},
{ 106, 126, 227, 252, 214, 209, 255, 255, 128, 128, 128}
},
{ /* coeff band 2 */
{ 1, 98, 248, 255, 236, 226, 255, 255, 128, 128, 128},
{ 181, 133, 238, 254, 221, 234, 255, 154, 128, 128, 128},
{ 78, 134, 202, 247, 198, 180, 255, 219, 128, 128, 128}
},
{ /* coeff band 3 */
{ 1, 185, 249, 255, 243, 255, 128, 128, 128, 128, 128},
{ 184, 150, 247, 255, 236, 224, 128, 128, 128, 128, 128},
{ 77, 110, 216, 255, 236, 230, 128, 128, 128, 128, 128}
},
{ /* coeff band 4 */
{ 1, 101, 251, 255, 241, 255, 128, 128, 128, 128, 128},
{ 170, 139, 241, 252, 236, 209, 255, 255, 128, 128, 128},
{ 37, 116, 196, 243, 228, 255, 255, 255, 128, 128, 128}
},
{ /* coeff band 5 */
{ 1, 204, 254, 255, 245, 255, 128, 128, 128, 128, 128},
{ 207, 160, 250, 255, 238, 128, 128, 128, 128, 128, 128},
{ 102, 103, 231, 255, 211, 171, 128, 128, 128, 128, 128}
},
{ /* coeff band 6 */
{ 1, 152, 252, 255, 240, 255, 128, 128, 128, 128, 128},
{ 177, 135, 243, 255, 234, 225, 128, 128, 128, 128, 128},
{ 80, 129, 211, 255, 194, 224, 128, 128, 128, 128, 128}
},
{ /* coeff band 7 */
{ 1, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 246, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 255, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
}
},
{ /* block type 1 */
{ /* coeff band 0 */
{ 198, 35, 237, 223, 193, 187, 162, 160, 145, 155, 62},
{ 131, 45, 198, 221, 172, 176, 220, 157, 252, 221, 1},
{ 68, 47, 146, 208, 149, 167, 221, 162, 255, 223, 128}
},
{ /* coeff band 1 */
{ 1, 149, 241, 255, 221, 224, 255, 255, 128, 128, 128},
{ 184, 141, 234, 253, 222, 220, 255, 199, 128, 128, 128},
{ 81, 99, 181, 242, 176, 190, 249, 202, 255, 255, 128}
},
{ /* coeff band 2 */
{ 1, 129, 232, 253, 214, 197, 242, 196, 255, 255, 128},
{ 99, 121, 210, 250, 201, 198, 255, 202, 128, 128, 128},
{ 23, 91, 163, 242, 170, 187, 247, 210, 255, 255, 128}
},
{ /* coeff band 3 */
{ 1, 200, 246, 255, 234, 255, 128, 128, 128, 128, 128},
{ 109, 178, 241, 255, 231, 245, 255, 255, 128, 128, 128},
{ 44, 130, 201, 253, 205, 192, 255, 255, 128, 128, 128}
},
{ /* coeff band 4 */
{ 1, 132, 239, 251, 219, 209, 255, 165, 128, 128, 128},
{ 94, 136, 225, 251, 218, 190, 255, 255, 128, 128, 128},
{ 22, 100, 174, 245, 186, 161, 255, 199, 128, 128, 128}
},
{ /* coeff band 5 */
{ 1, 182, 249, 255, 232, 235, 128, 128, 128, 128, 128},
{ 124, 143, 241, 255, 227, 234, 128, 128, 128, 128, 128},
{ 35, 77, 181, 251, 193, 211, 255, 205, 128, 128, 128}
},
{ /* coeff band 6 */
{ 1, 157, 247, 255, 236, 231, 255, 255, 128, 128, 128},
{ 121, 141, 235, 255, 225, 227, 255, 255, 128, 128, 128},
{ 45, 99, 188, 251, 195, 217, 255, 224, 128, 128, 128}
},
{ /* coeff band 7 */
{ 1, 1, 251, 255, 213, 255, 128, 128, 128, 128, 128},
{ 203, 1, 248, 255, 255, 128, 128, 128, 128, 128, 128},
{ 137, 1, 177, 255, 224, 255, 128, 128, 128, 128, 128}
}
},
{ /* block type 2 */
{ /* coeff band 0 */
{ 253, 9, 248, 251, 207, 208, 255, 192, 128, 128, 128},
{ 175, 13, 224, 243, 193, 185, 249, 198, 255, 255, 128},
{ 73, 17, 171, 221, 161, 179, 236, 167, 255, 234, 128}
},
{ /* coeff band 1 */
{ 1, 95, 247, 253, 212, 183, 255, 255, 128, 128, 128},
{ 239, 90, 244, 250, 211, 209, 255, 255, 128, 128, 128},
{ 155, 77, 195, 248, 188, 195, 255, 255, 128, 128, 128}
},
{ /* coeff band 2 */
{ 1, 24, 239, 251, 218, 219, 255, 205, 128, 128, 128},
{ 201, 51, 219, 255, 196, 186, 128, 128, 128, 128, 128},
{ 69, 46, 190, 239, 201, 218, 255, 228, 128, 128, 128}
},
{ /* coeff band 3 */
{ 1, 191, 251, 255, 255, 128, 128, 128, 128, 128, 128},
{ 223, 165, 249, 255, 213, 255, 128, 128, 128, 128, 128},
{ 141, 124, 248, 255, 255, 128, 128, 128, 128, 128, 128}
},
{ /* coeff band 4 */
{ 1, 16, 248, 255, 255, 128, 128, 128, 128, 128, 128},
{ 190, 36, 230, 255, 236, 255, 128, 128, 128, 128, 128},
{ 149, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{ /* coeff band 5 */
{ 1, 226, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 247, 192, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 240, 128, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{ /* coeff band 6 */
{ 1, 134, 252, 255, 255, 128, 128, 128, 128, 128, 128},
{ 213, 62, 250, 255, 255, 128, 128, 128, 128, 128, 128},
{ 55, 93, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{ /* coeff band 7 */
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
}
},
{ /* block type 3 */
{ /* coeff band 0 */
{ 202, 24, 213, 235, 186, 191, 220, 160, 240, 175, 255},
{ 126, 38, 182, 232, 169, 184, 228, 174, 255, 187, 128},
{ 61, 46, 138, 219, 151, 178, 240, 170, 255, 216, 128}
},
{ /* coeff band 1 */
{ 1, 112, 230, 250, 199, 191, 247, 159, 255, 255, 128},
{ 166, 109, 228, 252, 211, 215, 255, 174, 128, 128, 128},
{ 39, 77, 162, 232, 172, 180, 245, 178, 255, 255, 128}
},
{ /* coeff band 2 */
{ 1, 52, 220, 246, 198, 199, 249, 220, 255, 255, 128},
{ 124, 74, 191, 243, 183, 193, 250, 221, 255, 255, 128},
{ 24, 71, 130, 219, 154, 170, 243, 182, 255, 255, 128}
},
{ /* coeff band 3 */
{ 1, 182, 225, 249, 219, 240, 255, 224, 128, 128, 128},
{ 149, 150, 226, 252, 216, 205, 255, 171, 128, 128, 128},
{ 28, 108, 170, 242, 183, 194, 254, 223, 255, 255, 128}
},
{ /* coeff band 4 */
{ 1, 81, 230, 252, 204, 203, 255, 192, 128, 128, 128},
{ 123, 102, 209, 247, 188, 196, 255, 233, 128, 128, 128},
{ 20, 95, 153, 243, 164, 173, 255, 203, 128, 128, 128}
},
{ /* coeff band 5 */
{ 1, 222, 248, 255, 216, 213, 128, 128, 128, 128, 128},
{ 168, 175, 246, 252, 235, 205, 255, 255, 128, 128, 128},
{ 47, 116, 215, 255, 211, 212, 255, 255, 128, 128, 128}
},
{ /* coeff band 6 */
{ 1, 121, 236, 253, 212, 214, 255, 255, 128, 128, 128},
{ 141, 84, 213, 252, 201, 202, 255, 219, 128, 128, 128},
{ 42, 80, 160, 240, 162, 185, 255, 205, 128, 128, 128}
},
{ /* coeff band 7 */
{ 1, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 244, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 238, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128}
}
}
};
static const
unsigned char k_mv_entropy_update_probs[2][MV_PROB_CNT] =
{
{
237,
246,
253, 253, 254, 254, 254, 254, 254,
254, 254, 254, 254, 254, 250, 250, 252, 254, 254
},
{
231,
243,
245, 253, 254, 254, 254, 254, 254,
254, 254, 254, 254, 254, 251, 251, 254, 254, 254
}
};
static const
unsigned char k_default_mv_probs[2][MV_PROB_CNT] =
{
{ // row
162, // is short
128, // sign
225, 146, 172, 147, 214, 39, 156, // short tree
128, 129, 132, 75, 145, 178, 206, 239, 254, 254 // long bits
},
{
164,
128,
204, 170, 119, 235, 140, 230, 228,
128, 130, 130, 74, 148, 180, 203, 236, 254, 254
} };
}};
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
/*!\file vpx_codec_internal.h
* \brief Describes the decoder algorithm interface for algorithm
* implementations.
*
* This file defines the private structures and data types that are
* only relevant to implementing an algorithm, as opposed to using
* it.
*
* To create a decoder algorithm class, an interface structure is put
* into the global namespace:
* <pre>
* my_codec.c:
* vpx_codec_iface_t my_codec = {
* "My Codec v1.0",
* VPX_CODEC_ALG_ABI_VERSION,
* ...
* };
* </pre>
*
* An application instantiates a specific decoder instance by using
* vpx_codec_init() and a pointer to the algorithm's interface
* structure:
* <pre>
* my_app.c:
* extern vpx_codec_iface_t my_codec;
* {
* vpx_codec_ctx_t algo;
* res = vpx_codec_init(&algo, &my_codec);
* }
* </pre>
*
* Once initialized, the instance is managed using other functions
* from the vpx_codec_* family.
*/
#ifndef VPX_CODEC_INTERNAL_H
#define VPX_CODEC_INTERNAL_H
#include "vpx_decoder.h"
#include <stdarg.h>
/*!\brief Current ABI version number
*
* \internal
* If this file is altered in any way that changes the Application
* Binary Interface (ABI), this value must be bumped. Examples
* include, but are not limited to, changing types, removing or
* reassigning enums, adding/removing/rearranging fields to
* structures.
*/
#define VPX_CODEC_INTERNAL_ABI_VERSION (3)
typedef struct vpx_codec_alg_priv vpx_codec_alg_priv_t;
typedef struct vpx_codec_alg_priv vpx_codec_alg_priv_t;
/*!\brief init function pointer prototype
*
* Performs algorithm-specific initialization of the decoder context.
* This function is called by the generic vpx_codec_init() wrapper
* function, so plugins implementing this interface may trust the
* input parameters to be properly initialized.
*
* \param[in] ctx Pointer to this instance's context
* \retval #VPX_CODEC_OK
* The input stream was recognized and decoder initialized.
* \retval #VPX_CODEC_MEM_ERROR
* Memory operation failed.
*/
typedef vpx_codec_err_t (*vpx_codec_init_fn_t)(vpx_codec_ctx_t *ctx);
/*!\brief destroy function pointer prototype
*
* Performs algorithm-specific destruction of the decoder context.
* This function is called by the generic vpx_codec_destroy() wrapper
* function, so plugins implementing this interface may trust the
* input parameters to be properly initialized.
*
* \param[in] ctx Pointer to this instance's context
* \retval #VPX_CODEC_OK
* The input stream was recognized and decoder initialized.
* \retval #VPX_CODEC_MEM_ERROR
* Memory operation failed.
*/
typedef vpx_codec_err_t (*vpx_codec_destroy_fn_t)(
vpx_codec_alg_priv_t *ctx);
/*!\brief parse stream info function pointer prototype
*
* Performs high level parsing of the bitstream. This function is
* called by the generic vpx_codec_parse_stream() wrapper function,
* so plugins implementing this interface may trust the input
* parameters to be properly initialized.
*
* \param[in] data Pointer to a block of data to parse
* \param[in] data_sz Size of the data buffer
* \param[in,out] si Pointer to stream info to update. The
* size member \ref MUST be properly
* initialized, but \ref MAY be clobbered by
* the algorithm. This parameter \ref MAY
* be NULL.
*
* \retval #VPX_CODEC_OK
* Bitstream is parsable and stream information updated
*/
typedef vpx_codec_err_t (*vpx_codec_peek_si_fn_t)(
const uint8_t *data,
unsigned int data_sz,
vpx_codec_stream_info_t *si);
/*!\brief Return information about the current stream.
*
* Returns information about the stream that has been parsed during
* decoding.
*
* \param[in] ctx Pointer to this instance's context
* \param[in,out] si Pointer to stream info to update. The
* size member \ref MUST be properly
* initialized, but \ref MAY be clobbered by
* the algorithm. This parameter \ref MAY
* be NULL.
*
* \retval #VPX_CODEC_OK
* Bitstream is parsable and stream information updated
*/
typedef vpx_codec_err_t (*vpx_codec_get_si_fn_t)(
vpx_codec_alg_priv_t *ctx,
vpx_codec_stream_info_t *si);
/*!\brief control function pointer prototype
*
* This function is used to exchange algorithm-specific data with the
* decoder instance. This can be used to implement features specific
* to a particular algorithm.
*
* This function is called by the generic vpx_codec_control() wrapper
* function, so plugins implementing this interface may trust the
* input parameters to be properly initialized. However, this
* interface does not provide type safety for the exchanged data or
* assign meanings to the control codes. Those details should be
* specified in the algorithm's header file. In particular, the
* ctrl_id parameter is guaranteed to exist in the algorithm's
* control mapping table, and the data parameter may be NULL.
*
*
* \param[in] ctx Pointer to this instance's context
* \param[in] ctrl_id Algorithm-specific control identifier
* \param[in,out] data Data to exchange with algorithm instance.
*
* \retval #VPX_CODEC_OK
* The internal state data was deserialized.
*/
typedef vpx_codec_err_t (*vpx_codec_control_fn_t)(
vpx_codec_alg_priv_t *ctx,
int ctrl_id,
va_list ap);
/*!\brief control function pointer mapping
*
* This structure stores the mapping between control identifiers and
* implementing functions. Each algorithm provides a list of these
* mappings. This list is searched by the vpx_codec_control()
* wrapper function to determine which function to invoke. The
* special value {0, NULL} is used to indicate end-of-list, and must
* be present. The special value {0, <non-null>} can be used as a
* catch-all mapping. This implies that ctrl_id values chosen by the
* algorithm \ref MUST be non-zero.
*/
typedef const struct
{
int ctrl_id;
vpx_codec_control_fn_t fn;
} vpx_codec_ctrl_fn_map_t;
/*!\brief decode data function pointer prototype
*
* Processes a buffer of coded data. If the processing results in a
* new decoded frame becoming available, #VPX_CODEC_CB_PUT_SLICE and
* #VPX_CODEC_CB_PUT_FRAME events are generated as appropriate.
* This function is called by the generic vpx_codec_decode() wrapper
* function, so plugins implementing this interface may trust the
* input parameters to be properly initialized.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] data Pointer to this block of new coded data.
* If NULL, a #VPX_CODEC_CB_PUT_FRAME event is
* posted for the previously decoded frame.
* \param[in] data_sz Size of the coded data, in bytes.
*
* \return Returns #VPX_CODEC_OK if the coded data was processed
* completely and future pictures can be decoded without
* error. Otherwise, see the descriptions of the other error
* codes in ::vpx_codec_err_t for recoverability
* capabilities.
*/
typedef vpx_codec_err_t (*vpx_codec_decode_fn_t)(
vpx_codec_alg_priv_t *ctx,
const uint8_t *data,
unsigned int data_sz,
void *user_priv,
long deadline);
/*!\brief Decoded frames iterator
*
* Iterates over a list of the frames available for display. The
* iterator storage should be initialized to NULL to start the
* iteration. Iteration is complete when this function returns NULL.
*
* The list of available frames becomes valid upon completion of the
* vpx_codec_decode call, and remains valid until the next call to
* vpx_codec_decode.
*
* \param[in] ctx Pointer to this instance's context
* \param[in out] iter Iterator storage, initialized to NULL
*
* \return Returns a pointer to an image, if one is ready for
* display. Frames produced will always be in PTS
* (presentation time stamp) order.
*/
typedef vpx_image_t*(*vpx_codec_get_frame_fn_t)(
vpx_codec_alg_priv_t *ctx,
vpx_codec_iter_t *iter);
/*\brief External Memory Allocation memory map get iterator
*
* Iterates over a list of the memory maps requested by the decoder.
* The iterator storage should be initialized to NULL to start the
* iteration. Iteration is complete when this function returns NULL.
*
* \param[in out] iter Iterator storage, initialized to NULL
*
* \return Returns a pointer to a memory segment descriptor, or NULL
* to indicate end-of-list.
*/
typedef vpx_codec_err_t (*vpx_codec_get_mmap_fn_t)(
const vpx_codec_ctx_t *ctx,
vpx_codec_mmap_t *mmap,
vpx_codec_iter_t *iter);
/*\brief External Memory Allocation memory map set iterator
*
* Sets a memory descriptor inside the decoder instance.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] mmap Memory map to store.
*
* \retval #VPX_CODEC_OK
* The memory map was accepted and stored.
* \retval #VPX_CODEC_MEM_ERROR
* The memory map was rejected.
*/
typedef vpx_codec_err_t (*vpx_codec_set_mmap_fn_t)(
vpx_codec_ctx_t *ctx,
const vpx_codec_mmap_t *mmap);
typedef vpx_codec_err_t (*vpx_codec_encode_fn_t)(
vpx_codec_alg_priv_t *ctx,
const vpx_image_t *img,
vpx_codec_pts_t pts,
unsigned long duration,
vpx_enc_frame_flags_t flags,
unsigned long deadline);
typedef const vpx_codec_cx_pkt_t*(*vpx_codec_get_cx_data_fn_t)(
vpx_codec_alg_priv_t *ctx,
vpx_codec_iter_t *iter);
typedef vpx_codec_err_t
(*vpx_codec_enc_config_set_fn_t)(
vpx_codec_alg_priv_t *ctx,
const vpx_codec_enc_cfg_t *cfg);
typedef vpx_fixed_buf_t *
(*vpx_codec_get_global_headers_fn_t)(vpx_codec_alg_priv_t *ctx);
typedef vpx_image_t *
(*vpx_codec_get_preview_frame_fn_t)(vpx_codec_alg_priv_t *ctx);
/*!\brief usage configuration mapping
*
* This structure stores the mapping between usage identifiers and
* configuration structures. Each algorithm provides a list of these
* mappings. This list is searched by the
* vpx_codec_enc_config_default() wrapper function to determine which
* config to return. The special value {-1, {0}} is used to indicate
* end-of-list, and must be present. At least one mapping must be
* present, in addition to the end-of-list.
*
*/
typedef const struct
{
int usage;
vpx_codec_enc_cfg_t cfg;
} vpx_codec_enc_cfg_map_t;
#define NOT_IMPLEMENTED 0
#define not_implemented 0
/*!\brief Decoder algorithm interface
*
* All decoders \ref MUST expose a variable of this type.
*/
struct vpx_codec_iface
{
const char *name;
int abi_version;
vpx_codec_caps_t caps;
vpx_codec_init_fn_t init;
vpx_codec_destroy_fn_t destroy;
vpx_codec_ctrl_fn_map_t *ctrl_maps;
vpx_codec_get_mmap_fn_t get_mmap;
vpx_codec_set_mmap_fn_t set_mmap;
struct
{
vpx_codec_peek_si_fn_t peek_si;
vpx_codec_get_si_fn_t get_si;
vpx_codec_decode_fn_t decode;
vpx_codec_get_frame_fn_t get_frame;
} dec;
struct
{
vpx_codec_enc_cfg_map_t *cfg_maps;
vpx_codec_encode_fn_t encode;
vpx_codec_get_cx_data_fn_t get_cx_data;
vpx_codec_enc_config_set_fn_t cfg_set;
vpx_codec_get_global_headers_fn_t get_glob_hdrs;
vpx_codec_get_preview_frame_fn_t get_preview;
} enc;
};
/*!\brief Callback function pointer / user data pair storage */
typedef struct vpx_codec_priv_cb_pair
{
union
{
vpx_codec_put_frame_cb_fn_t put_frame;
vpx_codec_put_slice_cb_fn_t put_slice;
};
void *user_priv;
} vpx_codec_priv_cb_pair_t;
/*!\brief Instance private storage
*
* This structure is allocated by the algorithm's init function. It
* can be extended in one of two ways. First, a second, algorithm
* specific structure can be allocated and the priv member pointed to
* it. Alternatively, this structure can be made the first member of
* the algorithm-specific structure, and the pointer casted to the
* proper type.
*/
struct vpx_codec_priv
{
unsigned int sz;
vpx_codec_iface_t *iface;
struct vpx_codec_alg_priv *alg_priv;
const char *err_detail;
vpx_codec_flags_t init_flags;
struct
{
vpx_codec_priv_cb_pair_t put_frame_cb;
vpx_codec_priv_cb_pair_t put_slice_cb;
} dec;
struct
{
struct vpx_fixed_buf cx_data_dst_buf;
unsigned int cx_data_pad_before;
unsigned int cx_data_pad_after;
vpx_codec_cx_pkt_t cx_data_pkt;
} enc;
};
#undef VPX_CTRL_USE_TYPE
#define VPX_CTRL_USE_TYPE(id, typ) \
static typ id##__value(va_list args) \
{return va_arg(args, typ);} \
static typ id##__convert(void *x)\
{\
union\
{\
void *x;\
typ d;\
} u;\
u.x = x;\
return u.d;\
}
#undef VPX_CTRL_USE_TYPE_DEPRECATED
#define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ) \
static typ id##__value(va_list args) \
{return va_arg(args, typ);} \
static typ id##__convert(void *x)\
{\
union\
{\
void *x;\
typ d;\
} u;\
u.x = x;\
return u.d;\
}
#define CAST(id, arg) id##__value(arg)
#define RECAST(id, x) id##__convert(x)
/* Internal Utility Functions
*
* The following functions are intended to be used inside algorithms
* as utilities for manipulating vpx_codec_* data structures.
*/
struct vpx_codec_pkt_list
{
unsigned int cnt;
unsigned int max;
struct vpx_codec_cx_pkt pkts[1];
};
#define vpx_codec_pkt_list_decl(n)\
union {struct vpx_codec_pkt_list head;\
struct {struct vpx_codec_pkt_list head;\
struct vpx_codec_cx_pkt pkts[n];} alloc;}
#define vpx_codec_pkt_list_init(m)\
(m)->alloc.head.cnt = 0,\
(m)->alloc.head.max = \
sizeof((m)->alloc.pkts) / sizeof((m)->alloc.pkts[0])
int vpx_codec_pkt_list_add(struct vpx_codec_pkt_list *, const struct vpx_codec_cx_pkt *);
int vpx_codec_pkt_list_add（struct vpx_codec_pkt_list *、const struct vpx_codec_cx_pkt *）;
const vpx_codec_cx_pkt_t*
vpx_codec_pkt_list_get(struct vpx_codec_pkt_list *list,
vpx_codec_iter_t *iter);
#include <stdio.h>
#include <setjmp.h>
struct vpx_internal_error_info
{
vpx_codec_err_t error_code;
int has_detail;
char detail[80];
int setjmp;
jmp_buf jmp;
};
static void vpx_internal_error(struct vpx_internal_error_info *info, vpx_codec_err_t error, const char *fmt, ...) { va_list ap;
static void vpx_internal_error（struct vpx_internal_error_info *info、vpx_codec_err_tエラー、const char *fmt、...）{va_list ap;
info->error_code = error;
info->has_detail = 0;
if (fmt)
{
size_t sz = sizeof(info->detail);
info->has_detail = 1;
va_start(ap, fmt);
vsnprintf(info->detail, sz - 1, fmt, ap);
va_end(ap);
info->detail[sz-1] = '\0';
}
if (info->setjmp)
longjmp(info->jmp, info->error_code);
}
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
/*!\defgroup decoder Decoder Algorithm Interface
* \ingroup codec
* This abstraction allows applications using this decoder to easily
* support multiple video formats with minimal code duplication.
* This section describes the interface common to all decoders.
* @{
*/
/*!\file vpx_decoder.h
* \brief Describes the decoder algorithm interface to applications.
*
* This file describes the interface between an application and a
* video decoder algorithm.
*
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef VPX_DECODER_H
#define VPX_DECODER_H
#include "vpx_codec.h"
/*!\brief Current ABI version number
*
* \internal
* If this file is altered in any way that changes the ABI, this
* value must be bumped. Examples include, but are not limited
* to, changing types, removing or reassigning enums,
* adding/removing/rearranging fields to structures
*/
#define VPX_DECODER_ABI_VERSION (2 + VPX_CODEC_ABI_VERSION)
/*! \brief Decoder capabilities bitfield
*
* Each decoder advertises the capabilities it supports as part
* of its ::vpx_codec_iface_t interface structure. Capabilities
* are extra interfaces or functionality, and are not required
* to be supported by a decoder.
*
* The available flags are specified by VPX_CODEC_CAP_* defines.
*/
#define VPX_CODEC_CAP_PUT_SLICE 0x10000 /**< Will issue put_slice
callbacks */
#define VPX_CODEC_CAP_PUT_FRAME 0x20000 /**< Will issue put_frame
callbacks */
#define VPX_CODEC_CAP_POSTPROC 0x40000 /**< Can postprocess decoded
frame */
/*! \brief Initialization-time Feature Enabling
*
* Certain codec features must be known at initialization time,
* to allow for proper memory allocation.
*
* The available flags are specified by VPX_CODEC_USE_* defines.
*/
#define VPX_CODEC_USE_POSTPROC 0x10000 /**< Postprocess decoded
frame */
/*!\brief Stream properties
*
* This structure is used to query or set properties of the
* decoded stream. Algorithms may extend this structure with
* data specific to their bitstream by setting the sz member
* appropriately.
*/
typedef struct vpx_codec_stream_info
{
unsigned int sz; /**< Size of this structure */
unsigned int w; /**< Width (or 0 for unknown/default) */
unsigned int h; /**< Height (or 0 for unknown/default) */
unsigned int is_kf; /**< Current frame is a keyframe */
} vpx_codec_stream_info_t;
/* REQUIRED FUNCTIONS
*
* The following functions are required to be implemented for all
* decoders. They represent the base case functionality expected
* of all decoders.
*/
/*!\brief Initialization Configurations
*
* This structure is used to pass init time configuration options
* to the decoder.
*/
typedef struct vpx_codec_dec_cfg
{
unsigned int threads; /**< Maximum number of threads to use,
default 1 */
unsigned int w; /**< Width */
unsigned int h; /**< Height */
} vpx_codec_dec_cfg_t; /**< alias for struct vpx_codec_dec_cfg */
/*!\brief Initialize a decoder instance
*
* Initializes a decoder context using the given interface.
* Applications should call the vpx_codec_dec_init convenience
* macro instead of this function directly, to ensure that the
* ABI version number parameter is properly initialized.
*
* In XMA mode (activated by setting VPX_CODEC_USE_XMA in the
* flags parameter), the storage pointed to by the cfg parameter
* must be kept readable and stable until all memory maps have
* been set.
*
* \param[in] ctx Pointer to this instance's context.
* \param[in] iface Pointer to the algorithm interface to
* use.
* \param[in] cfg Configuration to use, if known. May be
* NULL.
* \param[in] flags Bitfield of VPX_CODEC_USE_* flags
* \param[in] ver ABI version number. Must be set to
* VPX_DECODER_ABI_VERSION
* \retval #VPX_CODEC_OK
* The decoder algorithm initialized.
* \retval #VPX_CODEC_MEM_ERROR
* Memory allocation failed.
*/
vpx_codec_err_t vpx_codec_dec_init_ver(
vpx_codec_ctx_t *ctx,
vpx_codec_iface_t *iface,
vpx_codec_dec_cfg_t *cfg,
vpx_codec_flags_t flags,
int ver);
/*!\brief Convenience macro for vpx_codec_dec_init_ver()
*
* Ensures the ABI version parameter is properly set.
*/
#define vpx_codec_dec_init(ctx, iface, cfg, flags) \
vpx_codec_dec_init_ver(ctx, iface, cfg, flags, \
VPX_DECODER_ABI_VERSION)
/*!\brief Parse stream info from a buffer
*
* Performs high level parsing of the bitstream. Construction of
* a decoder context is not necessary. Can be used to determine
* if the bitstream is of the proper format, and to extract
* information from the stream.
*
* \param[in] iface Pointer to the algorithm interface
* \param[in] data Pointer to a block of data to parse
* \param[in] data_sz Size of the data buffer
* \param[in,out] si Pointer to stream info to update. The
* size member
* \ref MUST be properly initialized, but
* \ref MAY be clobbered by the
* algorithm. This parameter \ref MAY be
* NULL.
*
* \retval #VPX_CODEC_OK
* Bitstream is parsable and stream information updated
*/
vpx_codec_err_t vpx_codec_peek_stream_info( vpx_codec_iface_t *iface, const uint8_t *data, unsigned int data_sz, vpx_codec_stream_info_t *si);
vpx_codec_err_t vpx_codec_peek_stream_info（vpx_codec_iface_t *iface、const uint8_t *data、unsigned int data_sz、vpx_codec_stream_info_t *si）;
/*!\brief Return information about the current stream.
*
* Returns information about the stream that has been parsed
* during decoding.
*
* \param[in] ctx Pointer to this instance's context
* \param[in,out] si Pointer to stream info to update. The
* size member \ref MUST be properly
* initialized, but \ref MAY be clobbered
* by the algorithm. This parameter \ref
* MAY be NULL.
*
* \retval #VPX_CODEC_OK
* Bitstream is parsable and stream information updated
*/
vpx_codec_err_t vpx_codec_get_stream_info(
vpx_codec_ctx_t *ctx,
vpx_codec_stream_info_t *si);
/*!\brief Decode data
*
* Processes a buffer of coded data. If the processing results
* in a new decoded frame becoming available, PUT_SLICE and
* PUT_FRAME events may be generated, as appropriate. Encoded
* data \ref MUST be passed in DTS (decode time stamp) order.
* Frames produced will always be in PTS (presentation time
* stamp) order.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] data Pointer to this block of new coded
* data. If NULL, a
* VPX_CODEC_CB_PUT_FRAME event is posted
* for the previously decoded frame.
* \param[in] data_sz Size of the coded data, in bytes.
* \param[in] user_priv Application-specific data to associate
* with this frame.
* \param[in] deadline Soft deadline the decoder should
* attempt to meet, in us. Set to zero
* for unlimited.
*
* \return Returns #VPX_CODEC_OK if the coded data was processed
* completely and future pictures can be decoded without
* error. Otherwise, see the descriptions of the other
* error codes in ::vpx_codec_err_t for recoverability
* capabilities.
*/
vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t *ctx,
const uint8_t *data,
unsigned int data_sz,
void *user_priv,
long deadline);
/*!\brief Decoded frames iterator
*
* Iterates over a list of the frames available for display. The
* iterator storage should be initialized to NULL to start the
* iteration. Iteration is complete when this function returns
* NULL.
*
* The list of available frames becomes valid upon completion of
* the vpx_codec_decode call, and remains valid until the next
* call to vpx_codec_decode.
*
* \param[in] ctx Pointer to this instance's context
* \param[in,out] iter Iterator storage, initialized to NULL
*
* \return Returns a pointer to an image, if one is ready for
* display. Frames produced will always be in PTS
* (presentation time stamp) order.
*/
vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t *ctx,
vpx_codec_iter_t *iter);
/*!\defgroup cap_put_frame Frame-Based Decoding Functions
*
* The following functions are required to be implemented for all
* decoders that advertise the VPX_CODEC_CAP_PUT_FRAME
* capability. Calling these functions for codecs that don't
* advertise this capability will result in an error code being
* returned, usually VPX_CODEC_ERROR
* @{
*/
/*!\brief put frame callback prototype
*
* This callback is invoked by the decoder to notify the
* application of the availability of decoded image data.
*/
typedef void (*vpx_codec_put_frame_cb_fn_t)(
void *user_priv,
const vpx_image_t *img);
/*!\brief Register for notification of frame completion.
*
* Registers a given function to be called when a decoded frame
* is available.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] cb Pointer to the callback function
* \param[in] user_priv User's private data
*
* \retval #VPX_CODEC_OK
* Callback successfully registered.
* \retval #VPX_CODEC_ERROR
* Decoder context not initialized, or algorithm not capable
* of posting slice completion.
*/
vpx_codec_err_t vpx_codec_register_put_frame_cb(
vpx_codec_ctx_t *ctx,
vpx_codec_put_frame_cb_fn_t cb,
void *user_priv);
/*!@} - end defgroup cap_put_frame */
/*!\defgroup cap_put_slice Slice-Based Decoding Functions
*
* The following functions are required to be implemented for all
* decoders that advertise the VPX_CODEC_CAP_PUT_SLICE
* capability. Calling these functions for codecs that don't
* advertise this capability will result in an error code being
* returned, usually VPX_CODEC_ERROR
* @{
*/
/*!\brief put slice callback prototype
*
* This callback is invoked by the decoder to notify the
* application of the availability of partially decoded image
* data.
*/
typedef void (*vpx_codec_put_slice_cb_fn_t)(
void *user_priv,
const vpx_image_t *img,
const vpx_image_rect_t *valid,
const vpx_image_rect_t *update);
/*!\brief Register for notification of slice completion.
*
* Registers a given function to be called when a decoded slice
* is available.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] cb Pointer to the callback function
* \param[in] user_priv User's private data
*
* \retval #VPX_CODEC_OK
* Callback successfully registered.
* \retval #VPX_CODEC_ERROR
* Decoder context not initialized, or algorithm not capable
* of posting slice completion.
*/
vpx_codec_err_t vpx_codec_register_put_slice_cb(
vpx_codec_ctx_t *ctx,
vpx_codec_put_slice_cb_fn_t cb,
void *user_priv);
/*!@} - end defgroup cap_put_slice*/
/*!@} - end defgroup decoder*/
#endif
#endif
#ifdef __cplusplus } #endif
#ifdef __cplusplus} #endif
#if !defined(VPX_CODEC_DISABLE_COMPAT) || !VPX_CODEC_DISABLE_COMPAT
#include "vpx_decoder_compat.h"
#endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
/*!\defgroup decoder Common Decoder Algorithm Interface
* This abstraction allows applications using this decoder to easily
* support multiple video formats with minimal code duplication.
* This section describes the interface common to all codecs.
* @{
*/
/*!\file
* \brief Provides a compatibility layer between version 1 and 2 of
* this API.
*
* This interface has been deprecated. Only existing code should
* make use of this interface, and therefore, it is only thinly
* documented. Existing code should be ported to the vpx_codec_*
* API.
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifndef VPX_DECODER_COMPAT_H #define VPX_DECODER_COMPAT_H
#ifndef vpx_decoder_compat_h #define vpx_decoder_compat_h
/*!\brief Decoder algorithm return codes */
typedef enum {
/*!\brief Operation completed without error */
VPX_DEC_OK = VPX_CODEC_OK,
/*!\brief Unspecified error */
VPX_DEC_ERROR = VPX_CODEC_ERROR,
/*!\brief Memory operation failed */
VPX_DEC_MEM_ERROR = VPX_CODEC_MEM_ERROR,
/*!\brief ABI version mismatch */
VPX_DEC_ABI_MISMATCH = VPX_CODEC_ABI_MISMATCH,
/*!\brief The given bitstream is not supported.
*
* The bitstream was unable to be parsed at the highest
* level. The decoder is unable to proceed. This error \ref
* SHOULD be treated as fatal to the stream.
*/
VPX_DEC_UNSUP_BITSTREAM = VPX_CODEC_UNSUP_BITSTREAM,
/*!\brief Encoded bitstream uses an unsupported feature
*
* The decoder does not implement a feature required by the
* encoder. This return code should only be used for
* features that prevent future pictures from being properly
* decoded. This error \ref MAY be treated as fatal to the
* stream or \ref MAY be treated as fatal to the current
* Group of Pictures (GOP).
*/
VPX_DEC_UNSUP_FEATURE = VPX_CODEC_UNSUP_FEATURE,
/*!\brief The coded data for this stream is corrupt or
* incomplete
*
* There was a problem decoding the current frame. This
* return code should only be used for failures that prevent
* future pictures from being properly decoded. This error
* \ref MAY be treated as fatal to the stream or \ref MAY be
* treated as fatal to the current GOP. If decoding is
* continued for the current GOP, artifacts may be present.
*/
VPX_DEC_CORRUPT_FRAME = VPX_CODEC_CORRUPT_FRAME,
/*!\brief An application-supplied parameter is not valid.
*
*/
VPX_DEC_INVALID_PARAM = VPX_CODEC_INVALID_PARAM,
/*!\brief An iterator reached the end of list.
*
*/
VPX_DEC_LIST_END = VPX_CODEC_LIST_END
} vpx_dec_err_t;
} vpx_dec_err_t;
/*! \brief Decoder capabilities bitfield
*
* Each decoder advertises the capabilities it supports as part
* of its ::vpx_dec_iface_t interface structure. Capabilities
* are extra interfaces or functionality, and are not required
* to be supported by a decoder.
*
* The available flags are specified by VPX_DEC_CAP_* defines.
*/
typedef int vpx_dec_caps_t;
#define VPX_DEC_CAP_PUT_SLICE 0x0001 /**< Will issue put_slice
callbacks */
#define VPX_DEC_CAP_PUT_FRAME 0x0002 /**< Will issue put_frame
callbacks */
#define VPX_DEC_CAP_XMA 0x0004 /**< Supports External Memory
Allocation */
/*!\brief Stream properties
*
* This structure is used to query or set properties of the
* decoded stream. Algorithms may extend this structure with
* data specific to their bitstream by setting the sz member
* appropriately.
*/
#if 1
typedef vpx_codec_stream_info_t vpx_dec_stream_info_t;
#else
typedef struct
{
unsigned int sz; /**< Size of this structure */
unsigned int w; /**< Width (or 0 for unknown/default) */
unsigned int h; /**< Height (or 0 for unknown/default) */
unsigned int is_kf; /**< Current frame is a keyframe */
} vpx_dec_stream_info_t;
#endif
#endif
/*!\brief Decoder interface structure.
*
* Contains function pointers and other data private to the
* decoder implementation. This structure is opaque to the
* application.
*/
typedef const struct vpx_codec_iface vpx_dec_iface_t;
typedef struct vpx_codec_priv vpx_dec_priv_t;
/*!\brief Iterator
*
* Opaque storage used for iterating over lists.
*/
typedef vpx_codec_iter_t vpx_dec_iter_t;
/*!\brief Decoder context structure
*
* All decoders \ref MUST support this context structure fully.
* In general, this data should be considered private to the
* decoder algorithm, and not be manipulated or examined by the
* calling application. Applications may reference the 'name'
* member to get a printable description of the algorithm.
*/
#if 1
typedef vpx_codec_ctx_t vpx_dec_ctx_t;
#else
typedef struct
{
const char *name; /**< Printable interface name */
vpx_dec_iface_t *iface; /**< Interface pointers */
vpx_dec_err_t err; /**< Last returned error */
vpx_dec_priv_t *priv; /**< Algorithm private storage */
} vpx_dec_ctx_t;
#endif
/*!\brief Return the build configuration
*
* Returns a printable string containing an encoded version of
* the build configuration. This may be useful to vpx support.
*
*/
const char *vpx_dec_build_config(void) DEPRECATED;
/*!\brief Return the name for a given interface
*
* Returns a human readable string for name of the given decoder
* interface.
*
* \param[in] iface Interface pointer
*
*/
const char *vpx_dec_iface_name(
vpx_dec_iface_t *iface) DEPRECATED;
/*!\brief Convert error number to printable string
*
* Returns a human readable string for the last error returned
* by the algorithm. The returned error will be one line and
* will not contain any newline characters.
*
*
* \param[in] err Error number.
*
*/
const char *vpx_dec_err_to_string(vpx_dec_err_t err) DEPRECATED;
/*!\brief Retrieve error synopsis for decoder context
*
* Returns a human readable string for the last error returned by
* the algorithm. The returned error will be one line and will
* not contain any newline characters.
*
*
* \param[in] ctx Pointer to this instance's context.
*
*/
const char *vpx_dec_error(vpx_dec_ctx_t *ctx) DEPRECATED;
/*!\brief Retrieve detailed error information for decoder context
*
* Returns a human readable string providing detailed information
* about the last error.
*
* \param[in] ctx Pointer to this instance's context.
*
* \retval NULL
* No detailed information is available.
*/
const char *vpx_dec_error_detail(vpx_dec_ctx_t *ctx) DEPRECATED;
/* REQUIRED FUNCTIONS
*
* The following functions are required to be implemented for all
* decoders. They represent the base case functionality expected
* of all decoders.
*/
/*!\brief Initialize a decoder instance
*
* Initializes a decoder context using the given interface.
* Applications should call the vpx_dec_init convenience macro
* instead of this function directly, to ensure that the ABI
* version number parameter is properly initialized.
*
* \param[in] ctx Pointer to this instance's context.
* \param[in] iface Pointer to the algorithm interface to use.
* \param[in] ver ABI version number. Must be set to
* VPX_DECODER_ABI_VERSION
* \retval #VPX_DEC_OK
* The decoder algorithm initialized.
* \retval #VPX_DEC_MEM_ERROR
* Memory allocation failed.
*/
vpx_dec_err_t vpx_dec_init_ver(
vpx_dec_ctx_t *ctx,
vpx_dec_iface_t *iface,
int ver) DEPRECATED;
#define vpx_dec_init(ctx, iface) \ vpx_dec_init_ver(ctx, iface, VPX_DECODER_ABI_VERSION)
#define vpx_dec_init（ctx、iface）\ vpx_dec_init_ver（ctx、iface、vpx_decoder_abi_version）
/*!\brief Destroy a decoder instance
*
* Destroys a decoder context, freeing any associated memory
* buffers.
*
* \param[in] ctx Pointer to this instance's context
*
* \retval #VPX_DEC_OK
* The decoder algorithm initialized.
* \retval #VPX_DEC_MEM_ERROR
* Memory allocation failed.
*/
vpx_dec_err_t vpx_dec_destroy(vpx_dec_ctx_t *ctx) DEPRECATED;
/*!\brief Get the capabilities of an algorithm.
*
* Retrieves the capabilities bitfield from the algorithm's
* interface.
*
* \param[in] iface Pointer to the algorithm interface
*
*/
vpx_dec_caps_t vpx_dec_get_caps(
vpx_dec_iface_t *iface) DEPRECATED;
/*!\brief Parse stream info from a buffer
*
* Performs high level parsing of the bitstream. Construction of
* a decoder context is not necessary. Can be used to determine
* if the bitstream is of the proper format, and to extract
* information from the stream.
*
* \param[in] iface Pointer to the algorithm interface
* \param[in] data Pointer to a block of data to parse
* \param[in] data_sz Size of the data buffer
* \param[in,out] si Pointer to stream info to update. The
* size member \ref MUST be properly
* initialized, but \ref MAY be
* clobbered by the algorithm. This
* parameter \ref MAY be NULL.
*
* \retval #VPX_DEC_OK
* Bitstream is parsable and stream information updated
*/
vpx_dec_err_t vpx_dec_peek_stream_info(
vpx_dec_iface_t *iface,
const uint8_t *data,
unsigned int data_sz,
vpx_dec_stream_info_t *si) DEPRECATED;
/*!\brief Return information about the current stream.
*
* Returns information about the stream that has been parsed
* during decoding.
*
* \param[in] ctx Pointer to this instance's context
* \param[in,out] si Pointer to stream info to update.
* The size member \ref MUST be properly
* initialized, but \ref MAY be clobbered
* by the algorithm. This parameter \ref
* MAY be NULL.
*
* \retval #VPX_DEC_OK
* Bitstream is parsable and stream information updated
*/
vpx_dec_err_t vpx_dec_get_stream_info(
vpx_dec_ctx_t *ctx,
vpx_dec_stream_info_t *si) DEPRECATED;
/*!\brief Control algorithm
*
* This function is used to exchange algorithm-specific data with
* the decoder instance. This can be used to implement features
* specific to a particular algorithm.
*
* This wrapper function dispatches the request to the helper
* function associated with the given ctrl_id. It tries to call
* this function transparently, but will return #VPX_DEC_ERROR if
* the request could not be dispatched.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] ctrl_id Algorithm-specific control
* identifier
* \param[in,out] data Data to exchange with algorithm
* instance.
*
* \retval #VPX_DEC_OK
* The control request was processed.
* \retval #VPX_DEC_ERROR
* The control request was not processed.
* \retval #VPX_DEC_INVALID_PARAM
* The data was not valid.
*/
vpx_dec_err_t vpx_dec_control(vpx_dec_ctx_t *ctx,
int ctrl_id,
void *data) DEPRECATED;
/*!\brief Decode data
*
* Processes a buffer of coded data. If the processing results
* in a new decoded frame becoming available,
* #VPX_DEC_CB_PUT_SLICE and #VPX_DEC_CB_PUT_FRAME events may be
* generated, as appropriate. Encoded data \ref MUST be passed
* in DTS (decode time stamp) order. Frames produced will always
* be in PTS (presentation time stamp) order.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] data Pointer to this block of new coded
* data. If NULL, a VPX_DEC_CB_PUT_FRAME
* event is posted for the previously
* decoded frame.
* \param[in] data_sz Size of the coded data, in bytes.
* \param[in] user_priv Application-specific data to associate
* with this frame.
* \param[in] rel_pts PTS relative to the previous frame, in
* us. If unknown or unavailable, set to
* zero.
*
* \return Returns #VPX_DEC_OK if the coded data was processed
* completely and future pictures can be decoded without
* error. Otherwise, see the descriptions of the other
* error codes in ::vpx_dec_err_t for recoverability
* capabilities.
*/
vpx_dec_err_t vpx_dec_decode(
vpx_dec_ctx_t *ctx,
uint8_t *data,
unsigned int data_sz,
void *user_priv,
int rel_pts) DEPRECATED;
/*!\brief Decoded frames iterator
*
* Iterates over a list of the frames available for display. The
* iterator storage should be initialized to NULL to start the
* iteration. Iteration is complete when this function returns
* NULL.
*
* The list of available frames becomes valid upon completion of
* the vpx_dec_decode call, and remains valid until the next call
* to vpx_dec_decode.
*
* \param[in] ctx Pointer to this instance's context
* \param[in out] iter Iterator storage, initialized to NULL
*
* \return Returns a pointer to an image, if one is ready for
* display. Frames produced will always be in PTS
* (presentation time stamp) order.
*/
vpx_image_t *vpx_dec_get_frame(vpx_dec_ctx_t *ctx,
vpx_dec_iter_t *iter) DEPRECATED;
/*!\defgroup cap_put_frame Frame-Based Decoding Functions
*
* The following functions are required to be implemented for all
* decoders that advertise the VPX_DEC_CAP_PUT_FRAME capability.
* Calling these functions for codecs that don't advertise this
* capability will result in an error code being returned,
* usually VPX_DEC_ERROR @{
*/
/*!\brief put frame callback prototype
*
* This callback is invoked by the decoder to notify the
* application of the availability of decoded image data.
*/
typedef void (*vpx_dec_put_frame_cb_fn_t)(
void *user_priv,
const vpx_image_t *img);
/*!\brief Register for notification of frame completion.
*
* Registers a given function to be called when a decoded frame
* is available.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] cb Pointer to the callback function
* \param[in] user_priv User's private data
*
* \retval #VPX_DEC_OK
* Callback successfully registered.
* \retval #VPX_DEC_ERROR
* Decoder context not initialized, or algorithm not capable
* of posting slice completion.
*/
vpx_dec_err_t vpx_dec_register_put_frame_cb(
vpx_dec_ctx_t *ctx,
vpx_dec_put_frame_cb_fn_t cb,
void *user_priv) DEPRECATED;
/*!@} - end defgroup cap_put_frame */
/*!\defgroup cap_put_slice Slice-Based Decoding Functions
*
* The following functions are required to be implemented for all
* decoders that advertise the VPX_DEC_CAP_PUT_SLICE capability.
* Calling these functions for codecs that don't advertise this
* capability will result in an error code being returned,
* usually VPX_DEC_ERROR
* @{
*/
/*!\brief put slice callback prototype
*
* This callback is invoked by the decoder to notify the
* application of the availability of partially decoded image
* data.
*/
typedef void (*vpx_dec_put_slice_cb_fn_t)(void *user_priv,
const vpx_image_t *img,
const vpx_image_rect_t *valid,
const vpx_image_rect_t *update);
/*!\brief Register for notification of slice completion.
*
* Registers a given function to be called when a decoded slice
* is available.
*
* \param[in] ctx Pointer to this instance's context
* \param[in] cb Pointer to the callback function
* \param[in] user_priv User's private data
*
* \retval #VPX_DEC_OK
* Callback successfully registered.
* \retval #VPX_DEC_ERROR
* Decoder context not initialized, or algorithm not capable
* of posting slice completion.
*/
vpx_dec_err_t vpx_dec_register_put_slice_cb(vpx_dec_ctx_t *ctx,
vpx_dec_put_slice_cb_fn_t cb,
void *user_priv) DEPRECATED;
/*!@} - end defgroup cap_put_slice*/
/*!\defgroup cap_xma External Memory Allocation Functions
*
* The following functions are required to be implemented for all
* decoders that advertise the VPX_DEC_CAP_XMA capability.
* Calling these functions for codecs that don't advertise this
* capability will result in an error code being returned,
* usually VPX_DEC_ERROR
* @{
*/
/*!\brief Memory Map Entry
*
* This structure is used to contain the properties of a memory
* segment. It is populated by the decoder in the request phase,
* and by the calling application once the requested allocation
* has been performed.
*/
#if 1
#define VPX_DEC_MEM_ZERO 0x1 /**< Segment must be zeroed by
allocation */
#define VPX_DEC_MEM_WRONLY 0x2 /**< Segment need not be
readable */
#define VPX_DEC_MEM_FAST 0x4 /**< Place in fast memory, if
available */
typedef struct vpx_codec_mmap vpx_dec_mmap_t;
#else
typedef struct vpx_dec_mmap
{
/*
* The following members are set by the codec when requesting
* a segment
*/
unsigned int id; /**< identifier for the segment's
contents */
unsigned long sz; /**< size of the segment, in bytes */
unsigned int align; /**< required alignment of the
segment, in bytes */
unsigned int flags; /**< bitfield containing segment
properties */
#define VPX_DEC_MEM_ZERO 0x1 /**< Segment must be zeroed by
allocation */
#define VPX_DEC_MEM_WRONLY 0x2 /**< Segment need not be
readable */
#define VPX_DEC_MEM_FAST 0x4 /**< Place in fast memory, if
available */
/* The following members are to be filled in by the
* allocation function */
void *base; /**< pointer to the allocated
segment */
void (*dtor)(struct vpx_dec_mmap *map); /**< destructor to
call */
void *priv; /**< allocator private storage */
} vpx_dec_mmap_t;
#endif
/*!\brief Initialize a decoder instance in external allocation
* mode
*
* Initializes a decoder context using the given interface.
* Applications should call the vpx_dec_xma_init convenience
* macro instead of this function directly, to ensure that the
* ABI version number parameter is properly initialized.
*
* \param[in] ctx Pointer to this instance's context.
* \param[in] iface Pointer to the algorithm interface to
* use.
* \param[in] ver ABI version number. Must be set to
* VPX_DECODER_ABI_VERSION
* \retval #VPX_DEC_OK
* The decoder algorithm initialized.
* \retval #VPX_DEC_ERROR
* Decoder does not support XMA mode.
*/
vpx_dec_err_t vpx_dec_xma_init_ver(vpx_dec_ctx_t *ctx,
vpx_dec_iface_t *iface,
int ver) DEPRECATED;
#define vpx_dec_xma_init(ctx, iface) \
vpx_dec_xma_init_ver(ctx, iface, VPX_DECODER_ABI_VERSION)
/*!\brief Iterate over the list of segments to allocate.
*
* Iterates over a list of the segments to allocate. The
* iterator storage should be initialized to NULL to start the
* iteration. Iteration is complete when this function returns
* VPX_DEC_LIST_END. The amount of memory needed to allocate is
* dependent upon the size of the encoded stream. This means
* that the stream info structure must be known at allocation
* time. It can be populated with the vpx_dec_peek_stream_info()
* function. In cases where the stream to be decoded is not
* available at allocation time, a fixed size must be requested.
* The decoder will not be able to decode streams larger than the
* size used at allocation time.
*
* \param[in] ctx Pointer to this instance's context.
* \param[out] mmap Pointer to the memory map entry to
* populate.
* \param[in] si Pointer to the stream info.
* \param[in out] iter Iterator storage, initialized to NULL
*
* \retval #VPX_DEC_OK
* The memory map entry was populated.
* \retval #VPX_DEC_ERROR
* Decoder does not support XMA mode.
* \retval #VPX_DEC_MEM_ERROR
* Unable to determine segment size from stream info.
*/
vpx_dec_err_t vpx_dec_get_mem_map(
vpx_dec_ctx_t *ctx,
vpx_dec_mmap_t *mmap,
const vpx_dec_stream_info_t *si,
vpx_dec_iter_t *iter) DEPRECATED;
/*!\brief Identify allocated segments to decoder instance
*
* Stores a list of allocated segments in the decoder. Segments
* \ref MUST be passed in the order they are read from
* vpx_dec_get_mem_map(), but may be passed in groups of any
* size. Segments \ref MUST be set only once. The allocation
* function \ref MUST ensure that the vpx_dec_mmap_t::base member
* is non-NULL. If the segment requires cleanup handling (e.g.,
* calling free() or close()) then the vpx_dec_mmap_t::dtor
* member \ref MUST be populated.
*
* \param[in] ctx Pointer to this instance's context.
* \param[in] mmaps Pointer to the first memory map
* entry in the list.
* \param[in] num_maps Number of entries being set at this
* time
*
* \retval #VPX_DEC_OK
* The segment was stored in the decoder context.
* \retval #VPX_DEC_ERROR
* Decoder does not support XMA mode.
* \retval #VPX_DEC_MEM_ERROR
* Segment base address was not set, or segment was already
* stored.
*/
*/
vpx_dec_err_t vpx_dec_set_mem_map( vpx_dec_ctx_t *ctx, vpx_dec_mmap_t *mmaps, unsigned int num_maps) DEPRECATED;
vpx_dec_err_t vpx_dec_set_mem_map（vpx_dec_ctx_t *ctx、vpx_dec_map_t *mmaps、unsigned int num_maps）Deprecated;
/*!@} - end defgroup cap_xma*/
/*!@} - end defgroup decoder*/
#endif #ifdef __cplusplus } #endif
#endif #ifdef __cplusplus} #endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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 <string.h>
#include "vpx/vpx_image.h"
static vpx_image_t *img_alloc_helper(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int stride_align, unsigned char *img_data) {
static vpx_image_t *img_alloc_helper（vpx_image_t *img、vpx_img_fmt_t fmt、unsigned int d_w、unsigned int d_h、unsigned int stride_align、unsigned char *img_data）{
unsigned int h, w, s, xcs, ycs, bps; int align;
符号なしのint h、w、s、xcs、ycs、bps;int align;
/* Treat align==0 like align==1 */
if (!stride_align)
stride_align = 1;
/* Validate alignment (must be power of 2) */
if (stride_align & (stride_align - 1))
goto fail;
/* Get sample size for this format */
switch (fmt)
{
case VPX_IMG_FMT_RGB32:
case VPX_IMG_FMT_RGB32_LE:
case VPX_IMG_FMT_ARGB:
case VPX_IMG_FMT_ARGB_LE:
bps = 32;
break;
case VPX_IMG_FMT_RGB24:
case VPX_IMG_FMT_BGR24:
bps = 24;
break;
case VPX_IMG_FMT_RGB565:
case VPX_IMG_FMT_RGB565_LE:
case VPX_IMG_FMT_RGB555:
case VPX_IMG_FMT_RGB555_LE:
case VPX_IMG_FMT_UYVY:
case VPX_IMG_FMT_YUY2:
case VPX_IMG_FMT_YVYU:
bps = 16;
break;
case VPX_IMG_FMT_I420:
case VPX_IMG_FMT_YV12:
case VPX_IMG_FMT_VPXI420:
case VPX_IMG_FMT_VPXYV12:
bps = 12;
break;
default:
bps = 16;
break;
}
/* Get chroma shift values for this format */
switch (fmt)
{
case VPX_IMG_FMT_I420:
case VPX_IMG_FMT_YV12:
case VPX_IMG_FMT_VPXI420:
case VPX_IMG_FMT_VPXYV12:
xcs = 1;
break;
default:
xcs = 0;
break;
}
switch (fmt)
{
case VPX_IMG_FMT_I420:
case VPX_IMG_FMT_YV12:
case VPX_IMG_FMT_VPXI420:
case VPX_IMG_FMT_VPXYV12:
ycs = 1;
break;
default:
ycs = 0;
break;
}
/* Calculate storage sizes given the chroma subsampling */
align = (1 << xcs) - 1;
w = (d_w + align) & ~align;
align = (1 << ycs) - 1;
h = (d_h + align) & ~align;
s = (fmt & VPX_IMG_FMT_PLANAR) ? w : bps * w / 8;
s = (s + stride_align - 1) & ~(stride_align - 1);
/* Allocate the new image */
if (!img)
{
img = (vpx_image_t *)calloc(1, sizeof(vpx_image_t));
if (!img) goto fail;
if（！img）goto fail;
img->self_allocd = 1;
}
else
{
memset(img, 0, sizeof(vpx_image_t));
}
img->img_data = img_data;
if (!img_data)
{
img->img_data = malloc((fmt & VPX_IMG_FMT_PLANAR) ?
h * w * bps / 8 : h * s);
img->img_data_owner = 1;
}
if (!img->img_data) goto fail;
if（！img-> img_data）goto fail;
img->fmt = fmt;
img->w = w;
img->h = h;
img->x_chroma_shift = xcs;
img->y_chroma_shift = ycs;
img->bps = bps;
/* Calculate strides */
img->stride[VPX_PLANE_Y] = img->stride[VPX_PLANE_ALPHA] = s;
img->stride[VPX_PLANE_U] = img->stride[VPX_PLANE_V] = s >> xcs;
/* Default viewport to entire image */
if (!vpx_img_set_rect(img, 0, 0, d_w, d_h))
return img;
fail: vpx_img_free(img); return NULL; }
失敗：vpx_img_free（img）;nullを返します。}
vpx_image_t *vpx_img_alloc(vpx_image_t *img,
vpx_img_fmt_t fmt,
unsigned int d_w,
unsigned int d_h,
unsigned int stride_align)
{
return img_alloc_helper(img, fmt, d_w, d_h, stride_align, NULL);
}
vpx_image_t *vpx_img_wrap(vpx_image_t *img,
vpx_img_fmt_t fmt,
unsigned int d_w,
unsigned int d_h,
unsigned int stride_align,
unsigned char *img_data)
{
return img_alloc_helper(img, fmt, d_w, d_h, stride_align,
img_data);
}
int vpx_img_set_rect(vpx_image_t *img, unsigned int x, unsigned int y, unsigned int w, unsigned int h) { unsigned char *data;
int vpx_img_set_rect（vpx_image_t *img、unsigned int x、unsigned int y、unsigned int w、unsigned int h）{unsigned char *data;
if (x + w <= img->w && y + h <= img->h)
{
img->d_w = w;
img->d_h = h;
/* Calculate plane pointers */
if (!(img->fmt & VPX_IMG_FMT_PLANAR))
{
img->planes[VPX_PLANE_PACKED] =
img->img_data + x * img->bps / 8 + y *
img->stride[VPX_PLANE_PACKED];
}
else
{
data = img->img_data;
if (img->fmt & VPX_IMG_FMT_HAS_ALPHA)
{
img->planes[VPX_PLANE_ALPHA] =
data + x + y * img->stride[VPX_PLANE_ALPHA];
data += img->h * img->stride[VPX_PLANE_ALPHA];
}
img->planes[VPX_PLANE_Y] =
data + x + y * img->stride[VPX_PLANE_Y];
data += img->h * img->stride[VPX_PLANE_Y];
if (!(img->fmt & VPX_IMG_FMT_UV_FLIP))
{
img->planes[VPX_PLANE_U] = data
+ (x >> img->x_chroma_shift)
+ (y >> img->y_chroma_shift) *
img->stride[VPX_PLANE_U];
data += (img->h >> img->y_chroma_shift) *
img->stride[VPX_PLANE_U];
img->planes[VPX_PLANE_V] = data
+ (x >> img->x_chroma_shift)
+ (y >> img->y_chroma_shift) *
img->stride[VPX_PLANE_V];
}
else
{
img->planes[VPX_PLANE_V] = data
+ (x >> img->x_chroma_shift)
+ (y >> img->y_chroma_shift) *
img->stride[VPX_PLANE_V];
data += (img->h >> img->y_chroma_shift) *
img->stride[VPX_PLANE_V];
img->planes[VPX_PLANE_U] = data
+ (x >> img->x_chroma_shift)
+ (y >> img->y_chroma_shift) *
img->stride[VPX_PLANE_U];
}
}
return 0; }
0を返します。}
return -1; }
return -1;}
void vpx_img_flip(vpx_image_t *img)
{
/* Note: In the calculation pointer adjustment calculation, we
* want the rhs to be promoted to a signed type. Section 6.3.1.8
* of the ISO C99 standard [ISO-C99] indicates that if the
* adjustment parameter is unsigned, the stride parameter will be
* promoted to unsigned, causing errors when the lhs is a larger
* type than the rhs.
*/
img->planes[VPX_PLANE_Y] += (signed)
(img->d_h - 1) * img->stride[VPX_PLANE_Y];
img->stride[VPX_PLANE_Y] = -img->stride[VPX_PLANE_Y];
img->planes[VPX_PLANE_U] += (signed)
((img->d_h >> img->y_chroma_shift) - 1)
* img->stride[VPX_PLANE_U];
img->stride[VPX_PLANE_U] = -img->stride[VPX_PLANE_U];
img->planes[VPX_PLANE_V] += (signed)
((img->d_h >> img->y_chroma_shift) - 1) *
img->stride[VPX_PLANE_V];
img->stride[VPX_PLANE_V] = -img->stride[VPX_PLANE_V];
img->planes[VPX_PLANE_ALPHA] += (signed)
(img->d_h - 1) * img->stride[VPX_PLANE_ALPHA];
img->stride[VPX_PLANE_ALPHA] = -img->stride[VPX_PLANE_ALPHA];
}
void vpx_img_free(vpx_image_t *img)
{
if (img)
{
if (img->img_data && img->img_data_owner)
free(img->img_data);
if (img->self_allocd)
free(img);
}
}
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
/*!\file
* \brief Describes the vpx image descriptor and associated
* operations
*
*/
#ifdef __cplusplus extern "C" { #endif
#ifdef __cplusplus extern "c" {#endif
#ifndef VPX_IMAGE_H #define VPX_IMAGE_H
#ifndef vpx_image_h #define vpx_image_h
/*!\brief Current ABI version number
*
* \internal
* If this file is altered in any way that changes the ABI, this
* value must be bumped. Examples include, but are not limited
* to, changing types, removing or reassigning enums,
* adding/removing/rearranging fields to structures
*/
#define VPX_IMAGE_ABI_VERSION (1) /**<\hideinitializer*/
#define VPX_IMG_FMT_PLANAR 0x100 /**< Image is a planar
format */
#define VPX_IMG_FMT_UV_FLIP 0x200 /**< V plane precedes U plane
in memory */
#define VPX_IMG_FMT_HAS_ALPHA 0x400 /**< Image has an alpha channel
component */
/*!\brief List of supported image formats */
typedef enum vpx_img_fmt {
VPX_IMG_FMT_NONE,
VPX_IMG_FMT_RGB24, /**< 24 bit per pixel packed RGB */
VPX_IMG_FMT_RGB32, /**< 32 bit per pixel packed 0RGB */
VPX_IMG_FMT_RGB565, /**< 16 bit per pixel, 565 */
VPX_IMGFMT_RGB555, /**< 16 bit per pixel, 555 */
VPX_IMG_FMT_UYVY, /**< UYVY packed YUV */
VPX_IMG_FMT_YUY2, /**< YUYV packed YUV */
VPX_IMG_FMT_YVYU, /**< YVYU packed YUV */
VPX_IMG_FMT_BGR24, /**< 24 bit per pixel packed BGR */
VPX_IMG_FMT_RGB32_LE, /**< 32 bit packed BGR0 */
VPX_IMG_FMT_ARGB, /**< 32 bit packed ARGB, alpha=255 */
VPX_IMG_FMT_ARGB_LE, /**< 32 bit packed BGRA, alpha=255 */
VPX_IMG_FMT_RGB565_LE, /**< 16 bit per pixel,
gggbbbbb rrrrrggg */
VPX_IMG_FMT_RGB555_LE, /**< 16 bit per pixel,
gggbbbbb 0rrrrrgg */
VPX_IMG_FMT_YV12 = VPX_IMG_FMT_PLANAR |
VPX_IMG_FMT_UV_FLIP | 1, /**< planar YVU */
VPX_IMG_FMT_I420 = VPX_IMG_FMT_PLANAR | 2,
VPX_IMG_FMT_VPXYV12 = VPX_IMG_FMT_PLANAR |
VPX_IMG_FMT_UV_FLIP | 3, /** < planar 4:2:0 format with
vpx color space */
VPX_IMG_FMT_VPXI420 = VPX_IMG_FMT_PLANAR | 4 /** < planar
4:2:0 format with vpx color space */
}
vpx_img_fmt_t; /**< alias for enum vpx_img_fmt */
#if !defined(VPX_CODEC_DISABLE_COMPAT) || !VPX_CODEC_DISABLE_COMPAT
/** \deprecated Use #VPX_IMG_FMT_PLANAR */
#define IMG_FMT_PLANAR VPX_IMG_FMT_PLANAR
/** \deprecated Use #VPX_IMG_FMT_UV_FLIP */
#define IMG_FMT_UV_FLIP VPX_IMG_FMT_UV_FLIP
/** \deprecated Use #VPX_IMG_FMT_HAS_ALPHA */
#define IMG_FMT_HAS_ALPHA VPX_IMG_FMT_HAS_ALPHA
/*!\brief Deprecated list of supported image formats
* \deprecated New code should use #vpx_img_fmt
*/
#define img_fmt vpx_img_fmt
/*!\brief alias for enum img_fmt.
* \deprecated New code should use #vpx_img_fmt_t
*/
#define img_fmt_t vpx_img_fmt_t
/** \deprecated Use #VPX_IMG_FMT_NONE */
#define IMG_FMT_NONE VPX_IMG_FMT_NONE
/** \deprecated Use #VPX_IMG_FMT_RGB24 */
#define IMG_FMT_RGB24 VPX_IMG_FMT_RGB24
/** \deprecated Use #VPX_IMG_FMT_RGB32 */
#define IMG_FMT_RGB32 VPX_IMG_FMT_RGB32
/** \deprecated Use #VPX_IMG_FMT_RGB565 */
#define IMG_FMT_RGB565 VPX_IMG_FMT_RGB565
/** \deprecated Use #VPX_IMG_FMT_RGB555 */
#define IMG_FMT_RGB555 VPX_IMG_FMT_RGB555
/** \deprecated Use #VPX_IMG_FMT_UYVY */
#define IMG_FMT_UYVY VPX_IMG_FMT_UYVY
/** \deprecated Use #VPX_IMG_FMT_YUY2 */
#define IMG_FMT_YUY2 VPX_IMG_FMT_YUY2
/** \deprecated Use #VPX_IMG_FMT_YVYU */
#define IMG_FMT_YVYU VPX_IMG_FMT_YVYU
/** \deprecated Use #VPX_IMG_FMT_BGR24 */
#define IMG_FMT_BGR24 VPX_IMG_FMT_BGR24
/**< \deprecated Use #VPX_IMG_FMT_RGB32_LE */
#define IMG_FMT_RGB32_LE VPX_IMG_FMT_RGB32_LE
/** \deprecated Use #VPX_IMG_FMT_ARGB */
#define IMG_FMT_ARGB VPX_IMG_FMT_ARGB
/** \deprecated Use #VPX_IMG_FMT_ARGB_LE */
#define IMG_FMT_ARGB_LE VPX_IMG_FMT_ARGB_LE
/** \deprecated Use #VPX_IMG_FMT_RGB565_LE */
#define IMG_FMT_RGB565_LE VPX_IMG_FMT_RGB565_LE
/** \deprecated Use #VPX_IMG_FMT_RGB555_LE */
#define IMG_FMT_RGB555_LE VPX_IMG_FMT_RGB555_LE
/** \deprecated Use #VPX_IMG_FMT_YV12 */
#define IMG_FMT_YV12 VPX_IMG_FMT_YV12
/** \deprecated Use #VPX_IMG_FMT_I420 */
#define IMG_FMT_I420 VPX_IMG_FMT_I420
/** \deprecated Use #VPX_IMG_FMT_VPXYV12 */
#define IMG_FMT_VPXYV12 VPX_IMG_FMT_VPXYV12
/** \deprecated Use #VPX_IMG_FMT_VPXI420 */
#define IMG_FMT_VPXI420 VPX_IMG_FMT_VPXI420
#endif /* VPX_CODEC_DISABLE_COMPAT */
/**\brief Image Descriptor */
typedef struct vpx_image
{
vpx_img_fmt_t fmt; /**< Image Format */
/* Image storage dimensions */
unsigned int w; /**< Stored image width */
unsigned int h; /**< Stored image height */
/* Image display dimensions */
unsigned int d_w; /**< Displayed image width */
unsigned int d_h; /**< Displayed image height */
/* Chroma subsampling info */
unsigned int x_chroma_shift; /**< subsampling order, X */
unsigned int y_chroma_shift; /**< subsampling order, Y */
/* Image data pointers. */
#define VPX_PLANE_PACKED 0 /**< To be used for all packed formats */
#define VPX_PLANE_Y 0 /**< Y (Luminance) plane */
#define VPX_PLANE_U 1 /**< U (Chroma) plane */
#define VPX_PLANE_V 2 /**< V (Chroma) plane */
#define VPX_PLANE_ALPHA 3 /**< A (Transparency) plane */
#if !defined(VPX_CODEC_DISABLE_COMPAT) || !VPX_CODEC_DISABLE_COMPAT
#define PLANE_PACKED VPX_PLANE_PACKED
#define PLANE_Y VPX_PLANE_Y
#define PLANE_U VPX_PLANE_U
#define PLANE_V VPX_PLANE_V
#define PLANE_ALPHA VPX_PLANE_ALPHA
#endif
unsigned char *planes[4]; /**< pointer to the top-left pixel
q for each plane */
int stride[4]; /**< stride between rows for each plane */
int bps; /**< bits per sample (for packed formats) */
/* The following member may be set by the application to
* associate data with this image.
*/
void *user_priv; /**< may be set by the application to
associate data with this image. */
/* The following members should be treated as private. */
unsigned char *img_data; /**< private */
int img_data_owner; /**< private */
int self_allocd; /**< private */
} vpx_image_t; /**< alias for struct vpx_image */
/**\brief Representation of a rectangle on a surface */
typedef struct vpx_image_rect
{
unsigned int x; /**< leftmost column */
unsigned int y; /**< topmost row */
unsigned int w; /**< width */
unsigned int h; /**< height */
} vpx_image_rect_t; /**< alias for struct vpx_image_rect */
/*!\brief Open a descriptor, allocating storage for the
* underlying image
*
* Returns a descriptor for storing an image of the given format.
* The storage for the descriptor is allocated on the heap.
*
* \param[in] img Pointer to storage for descriptor.
* If this parameter is NULL, the storage
* for the descriptor will be allocated
* on the heap.
* \param[in] fmt Format for the image
* \param[in] d_w Width of the image
* \param[in] d_h Height of the image
* \param[in] align Alignment, in bytes, of each row in
* the image.
*
* \return Returns a pointer to the initialized image descriptor.
* If the img parameter is non-null, the value of the img
* parameter will be returned.
*/
vpx_image_t *vpx_img_alloc(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align);
vpx_image_t *vpx_img_alloc（vpx_image_t *img、vpx_img_fmt_t fmt、unsigned int d_w、unsigned int d_h、unsigned int align）;
/*!\brief Open a descriptor, using existing storage for the
* underlying image
*
* Returns a descriptor for storing an image of the given format.
* The storage for descriptor has been allocated elsewhere, and a
* descriptor is desired to "wrap" that storage.
*
* \param[in] img Pointer to storage for descriptor.
* If this parameter is NULL, the storage
* for the descriptor will be
* allocated on the heap.
* \param[in] fmt Format for the image
* \param[in] d_w Width of the image
* \param[in] d_h Height of the image
* \param[in] align Alignment, in bytes, of each row in
* the image.
* \param[in] img_data Storage to use for the image
*
* \return Returns a pointer to the initialized image descriptor.
* If the img parameter is non-null, the value of the img
* parameter will be returned.
*/
vpx_image_t *vpx_img_wrap(vpx_image_t *img,
vpx_img_fmt_t fmt,
unsigned int d_w,
unsigned int d_h,
unsigned int align,
unsigned char *img_data);
/*!\brief Set the rectangle identifying the displayed portion of
* the image
*
* Updates the displayed rectangle (aka viewport) on the image
* surface to match the specified coordinates and size.
*
* \param[in] img Image descriptor
* \param[in] x leftmost column
* \param[in] y topmost row
* \param[in] w width
* \param[in] h height
*
* \return 0 if the requested rectangle is valid, non-zero * otherwise. */ int vpx_img_set_rect(vpx_image_t *img, unsigned int x, unsigned int y, unsigned int w, unsigned int h);
* \ return 0要求された長方形が有効である場合、それ以外の場合は非ゼロ *。*/ int vpx_img_set_rect（vpx_image_t *img、unsigned int x、unsigned int y、unsigned int w、unsigned int h）;
/*!\brief Flip the image vertically (top for bottom)
*
* Adjusts the image descriptor's pointers and strides to make
* the image be referenced upside-down.
*
* \param[in] img Image descriptor
*/
void vpx_img_flip(vpx_image_t *img);
/*!\brief Close an image descriptor
*
* Frees all allocated storage associated with an image
* descriptor.
*
* \param[in] img Image descriptor
*/
void vpx_img_free(vpx_image_t *img);
#endif #ifdef __cplusplus } #endif
#endif #ifdef __cplusplus} #endif
---- End code block ----------------------------------------
---- Begin code block --------------------------------------
/*
* Copyright (c) 2010, 2011, Google Inc. 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.
*/
#ifndef VPX_INTEGER_H #define VPX_INTEGER_H
#ifndef vpx_integer_h #define vpx_integer_h
/* get ptrdiff_t, size_t, wchar_t, NULL */
#include <stddef.h>
#if defined(_MSC_VER) || defined(VPX_EMULATE_INTTYPES)
typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
#if defined(_MSC_VER) typedef signed __int64 int64_t; typedef unsigned __int64 uint64_t; #define PRId64 "I64d" #endif
#if defined（_msc_ver）typedef署名__int64 int64_t;typedef unsigned __int64 uint64_t;#define prid64 "i64d" #endif
#ifdef HAVE_ARMV6
typedef unsigned int int_fast16_t;
#else
typedef signed short int_fast16_t;
#endif
typedef signed char int_fast8_t;
typedef unsigned char uint_fast8_t;
#ifndef _UINTPTR_T_DEFINED typedef unsigned int uintptr_t; #endif
#ifndef _uintptr_t_defined typedef unsigned int uintptr_t;#endif
#else
＃そうしないと
/* Most platforms have the C99 standard integer types. */
#if defined(__cplusplus) && !defined(__STDC_FORMAT_MACROS)
#define __STDC_FORMAT_MACROS
#endif
#include <stdint.h>
#include <inttypes.h>
#endif
#endif
#endif
#endif
---- End code block ----------------------------------------
Aaron Watry <awatry@gmail.com>
Adrian Grange <agrange@google.com>
Alex Converse <alex.converse@gmail.com>
Andoni Morales Alastruey <ylatuya@gmail.com>
Andres Mejia <mcitadel@gmail.com>
Attila Nagy <attilanagy@google.com>
Fabio Pedretti <fabio.ped@libero.it>
Frank Galligan <fgalligan@google.com>
Fredrik Soederquist <fs@opera.com>
Fritz Koenig <frkoenig@google.com>
Gaute Strokkenes <gaute.strokkenes@broadcom.com>
Giuseppe Scrivano <gscrivano@gnu.org>
Guillermo Ballester Valor <gbvalor@gmail.com>
Henrik Lundin <hlundin@google.com>
James Berry <jamesberry@google.com>
James Zern <jzern@google.com>
Jan Kratochvil <jan.kratochvil@redhat.com>
Jeff Muizelaar <jmuizelaar@mozilla.com>
Jim Bankoski <jimbankoski@google.com>
Johann Koenig <johannkoenig@google.com>
John Koleszar <jkoleszar@google.com>
Justin Clift <justin@salasaga.org>
Justin Lebar <justin.lebar@gmail.com>
Luca Barbato <lu_zero@gentoo.org>
Makoto Kato <makoto.kt@gmail.com>
Martin Ettl <ettl.martin78@googlemail.com>
Michael Kohler <michaelkohler@live.com>
Mikhal Shemer <mikhal@google.com>
Pascal Massimino <pascal.massimino@gmail.com>
Patrik Westin <patrik.westin@gmail.com>
Paul Wilkins <paulwilkins@google.com>
Pavol Rusnak <stick@gk2.sk>
Philip Jaegenstedt <philipj@opera.com>
Scott LaVarnway <slavarnway@google.com>
Tero Rintaluoma <teror@google.com>
Timothy B. Terriberry <tterribe@xiph.org>
Tom Finegan <tomfinegan@google.com>
Yaowu Xu <yaowu@google.com>
Yunqing Wang <yunqingwang@google.com>
Google Inc.
Google Inc.
The Mozilla Foundation
モジラ財団
The Xiph.Org Foundation
Xiph.org Foundation
Copyright (c) 2010, 2011, Google Inc. All rights reserved.
Copyright（c）2010、2011、Google Inc. All Rights Reserved。
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
次の条件が満たされていれば、変更を加えた、または修正なしの有無にかかわらず、ソースおよびバイナリ形式での再配布と使用が許可されます。
o Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
o ソースコードの再配布は、上記の著作権通知、この条件リスト、および次の免責事項を保持する必要があります。
o Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
o バイナリ形式の再配布は、上記の著作権通知、この条件リスト、および分布に提供されたドキュメントおよび/またはその他の資料の次の免責事項を再現する必要があります。
o Neither the name of Google nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
o Googleの名前もその貢献者の名前も、特定の事前の書面による許可なしにこのソフトウェアから派生した製品を支持または宣伝するために使用することはできません。
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
このソフトウェアは、「現状のまま」の著作権所有者と貢献者によって提供され、特定の目的に対する商品性と適合性の暗黙の保証を含むがこれらに限定されない明示的または黙示的な保証が否認されます。いかなる場合でも、著作権所有者または貢献者は、直接的、間接的、偶発的、特別な、模範的、または結果的な損害賠償（代替品またはサービスの調達、使用の損失、データ、または利益）に対して責任を負いません。ただし、契約、厳格責任、または不法行為（過失などを含む）であろうと、このソフトウェアの使用から何らかの形で発生するかどうかにかかわらず、責任の理論に起因します。
Additional IP Rights Grant (Patents)
追加のIP権利助成金（特許）
"This implementation" means the copyrightable works distributed by Google as part of the WebM Project.
「この実装」とは、WebMプロジェクトの一部としてGoogleが配布した著作権で保護可能な作品を意味します。
Google hereby grants to you a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, transfer, and otherwise run, modify and propagate the contents of this implementation of VP8, where such license applies only to those patent claims, both currently owned by Google and acquired in the future, licensable by Google that are necessarily infringed by this implementation of VP8. This grant does not include claims that would be infringed only as a consequence of further modification of this implementation. If you or your agent or exclusive licensee institute or order or agree to the institution of patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that this implementation of VP8 or any code incorporated within this implementation of VP8 constitutes direct or contributory patent infringement, or inducement of patent infringement, then any patent rights granted to you under this License for this implementation of VP8 shall terminate as of the date such litigation is filed.
Googleは、ここにあなたにあなたに与えます、世界的な、世界的な、非独占的、充電なし、ロイヤリティフリー、取り返しのつかない（このセクションに記載されている場合を除く）特許ライセンスを作成、使用、使用、販売、販売、輸入、譲渡、その他の方法では、このVP8が現在所有しており、将来取得している特許請求にのみ適用されるVP8の実装の内容を実行、変更、伝播します。この助成金には、この実装のさらなる変更の結果としてのみ侵害される請求は含まれていません。あなたまたはあなたのエージェントまたは排他的ライセンシー研究所または命令または命令または同意するか、VP8またはVP8の実施に組み込まれたこのコードの実施が構成されていると主張する事業体に対する特許訴訟の機関（訴訟の相互訴訟または反訴を含む）に同意する場合直接的または拠出的な特許侵害、または特許侵害の誘因、このVP8の実施のためにこの免許に基づいてお客様に付与された特許権は、そのような訴訟が提出される日付の時点で終了するものとします。
A VP8 decoder should take appropriate security considerations into account, as outlined in [RFC4732] and [RFC3552]. It is extremely important that a decoder be robust against malicious payloads. Malicious payloads must not cause the decoder to overrun its allocated memory or to consume inordinate resources. Although encoder issues are typically rarer, the same applies to an encoder. Malicious stream data must not cause the encoder to misbehave, as this might allow an attacker access to transcoding gateways.
VP8デコーダーは、[RFC4732]および[RFC3552]で概説されているように、適切なセキュリティに関する考慮事項を考慮に入れる必要があります。デコーダーが悪意のあるペイロードに対して堅牢であることが非常に重要です。悪意のあるペイロードにより、デコーダーが割り当てられたメモリをオーバーランさせたり、過度のリソースを消費したりしてはなりません。通常、エンコーダーの問題はまれですが、エンコーダーにも同じことが当てはまります。悪意のあるストリームデータは、攻撃者がトランスコーディングゲートウェイへのアクセスを可能にする可能性があるため、エンコーダーを不正にしてはなりません。
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
[RFC2119] Bradner、S。、「要件レベルを示すためにRFCで使用するためのキーワード」、BCP 14、RFC 2119、1997年3月。
[Bell] Bell, T., Cleary, J., and I. Witten, "Text Compression", 1990.
[ベル]ベル、T。、クリアリー、J。、およびI.ウィッテン、「テキスト圧縮」、1990。
[ISO-C99] International Organization for Standardization, "Information technology -- Programming languages -- C", ISO/IEC 9899:1999, 1999.
[ISO-C99]国際標準化機関、「情報技術 - プログラミング言語-C」、ISO/IEC 9899：1999、1999。
[ITU-R_BT.601] International Telecommunication Union, "ITU BT.601-7: Studio encoding parameters of digital television for standard 4:3 and wide screen 16:9 aspect ratios", March 2011.
[ITU-R_BT.601] International Telecommunication Union、「ITU BT.601-7：2011年3月、標準4：3およびワイドスクリーン16：9のアスペクト比のためのデジタルテレビのパラメーターをエンコードするスタジオ」。
[Kernighan] Kernighan, B. and D. Ritchie, "The C Programming Language (2nd edition)", April 1988.
[Kernighan] Kernighan、B。およびD. Ritchie、「The Cプログラミング言語（第2版）」、1988年4月。
[Loeffler] Loeffler, C., Ligtenberg , A., and G. Moschytz, "Practical Fast 1-D DCT Algorithms with 11 Multiplications", May 1989.
[Loeffler] Loeffler、C.、Ligtenberg、A。、およびG. Moschytz、「11乗を伴う実用的な高速1-D DCTアルゴリズム」、1989年5月。
[RFC3552] Rescorla, E. and B. Korver, "Guidelines for Writing RFC Text on Security Considerations", BCP 72, RFC 3552, July 2003.
[RFC3552] Rescorla、E。およびB. Korver、「セキュリティに関する考慮事項に関するRFCテキストを書くためのガイドライン」、BCP 72、RFC 3552、2003年7月。
[RFC4732] Handley, M., Ed., Rescorla, E., Ed., and IAB, "Internet Denial-of-Service Considerations", RFC 4732, December 2006.
[RFC4732] Handley、M.、Ed。、Rescorla、E.、ed。、およびIAB、「インターネット拒否に関する考慮事項」、RFC 4732、2006年12月。
[Shannon] Shannon, C., "A Mathematical Theory of Communication", Bell System Technical Journal Vol. 27, pp. 379-423 and 623-656, July and October 1948.
[シャノン]シャノン、C。、「コミュニケーションの数学理論」、Bell System Technical Journal Vol。27、pp。379-423および623-656、1948年7月と10月。
Authors' Addresses
著者のアドレス
James Bankoski Google Inc.
James Bankoski Google Inc.
EMail: jimbankoski@google.com
John Koleszar Google Inc.
John Koleszar Google Inc.
EMail: jkoleszar@google.com
Lou Quillio Google Inc.
Lou Quillio Google Inc.
EMail: louquillio@google.com
Janne Salonen Google Inc.
Janne Salonen Google Inc.
EMail: jsalonen@google.com
Paul Wilkins Google Inc.
Paul Wilkins Google Inc.
EMail: paulwilkins@google.com
Yaowu Xu Google Inc.
Yaowu Xu Google Inc.
EMail: yaowu@google.com