FFmpeg
xvididct.c
Go to the documentation of this file.
1 /*
2  * Xvid MPEG-4 IDCT
3  *
4  * Copyright (C) 2006-2011 Xvid Solutions GmbH
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Walken IDCT
26  * Alternative IDCT implementation for decoding compatibility.
27  *
28  * @author Skal
29  * @note This C version is not the original IDCT, but a modified one that
30  * yields the same error profile as the MMX/MMXEXT/SSE2 versions.
31  */
32 
33 #include "config.h"
34 #include "libavutil/attributes.h"
35 #include "avcodec.h"
36 #include "idctdsp.h"
37 #include "xvididct.h"
38 
39 #define ROW_SHIFT 11
40 #define COL_SHIFT 6
41 
42 // #define FIX(x) (int)((x) * (1 << ROW_SHIFT))
43 #define RND0 65536 // 1 << (COL_SHIFT + ROW_SHIFT - 1);
44 #define RND1 3597 // FIX (1.75683487303);
45 #define RND2 2260 // FIX (1.10355339059);
46 #define RND3 1203 // FIX (0.587788325588);
47 #define RND4 0
48 #define RND5 120 // FIX (0.058658283817);
49 #define RND6 512 // FIX (0.25);
50 #define RND7 512 // FIX (0.25);
51 
52 static const int TAB04[] = { 22725, 21407, 19266, 16384, 12873, 8867, 4520 };
53 static const int TAB17[] = { 31521, 29692, 26722, 22725, 17855, 12299, 6270 };
54 static const int TAB26[] = { 29692, 27969, 25172, 21407, 16819, 11585, 5906 };
55 static const int TAB35[] = { 26722, 25172, 22654, 19266, 15137, 10426, 5315 };
56 
57 static int idct_row(short *in, const int *const tab, int rnd)
58 {
59  const int c1 = tab[0];
60  const int c2 = tab[1];
61  const int c3 = tab[2];
62  const int c4 = tab[3];
63  const int c5 = tab[4];
64  const int c6 = tab[5];
65  const int c7 = tab[6];
66 
67  const int right = in[5] | in[6] | in[7];
68  const int left = in[1] | in[2] | in[3];
69  if (!(right | in[4])) {
70  const int k = c4 * in[0] + rnd;
71  if (left) {
72  const int a0 = k + c2 * in[2];
73  const int a1 = k + c6 * in[2];
74  const int a2 = k - c6 * in[2];
75  const int a3 = k - c2 * in[2];
76 
77  const int b0 = c1 * in[1] + c3 * in[3];
78  const int b1 = c3 * in[1] - c7 * in[3];
79  const int b2 = c5 * in[1] - c1 * in[3];
80  const int b3 = c7 * in[1] - c5 * in[3];
81 
82  in[0] = (a0 + b0) >> ROW_SHIFT;
83  in[1] = (a1 + b1) >> ROW_SHIFT;
84  in[2] = (a2 + b2) >> ROW_SHIFT;
85  in[3] = (a3 + b3) >> ROW_SHIFT;
86  in[4] = (a3 - b3) >> ROW_SHIFT;
87  in[5] = (a2 - b2) >> ROW_SHIFT;
88  in[6] = (a1 - b1) >> ROW_SHIFT;
89  in[7] = (a0 - b0) >> ROW_SHIFT;
90  } else {
91  const int a0 = k >> ROW_SHIFT;
92  if (a0) {
93  in[0] =
94  in[1] =
95  in[2] =
96  in[3] =
97  in[4] =
98  in[5] =
99  in[6] =
100  in[7] = a0;
101  } else
102  return 0;
103  }
104  } else if (!(left | right)) {
105  const int a0 = (rnd + c4 * (in[0] + in[4])) >> ROW_SHIFT;
106  const int a1 = (rnd + c4 * (in[0] - in[4])) >> ROW_SHIFT;
107 
108  in[0] = a0;
109  in[3] = a0;
110  in[4] = a0;
111  in[7] = a0;
112  in[1] = a1;
113  in[2] = a1;
114  in[5] = a1;
115  in[6] = a1;
116  } else {
117  const int k = c4 * in[0] + rnd;
118  const unsigned int a0 = k + c2 * in[2] + c4 * in[4] + c6 * in[6];
119  const unsigned int a1 = k + c6 * in[2] - c4 * in[4] - c2 * in[6];
120  const unsigned int a2 = k - c6 * in[2] - c4 * in[4] + c2 * in[6];
121  const unsigned int a3 = k - c2 * in[2] + c4 * in[4] - c6 * in[6];
122 
123  const unsigned int b0 = c1 * in[1] + c3 * in[3] + c5 * in[5] + c7 * in[7];
124  const unsigned int b1 = c3 * in[1] - c7 * in[3] - c1 * in[5] - c5 * in[7];
125  const unsigned int b2 = c5 * in[1] - c1 * in[3] + c7 * in[5] + c3 * in[7];
126  const unsigned int b3 = c7 * in[1] - c5 * in[3] + c3 * in[5] - c1 * in[7];
127 
128  in[0] = (int)(a0 + b0) >> ROW_SHIFT;
129  in[1] = (int)(a1 + b1) >> ROW_SHIFT;
130  in[2] = (int)(a2 + b2) >> ROW_SHIFT;
131  in[3] = (int)(a3 + b3) >> ROW_SHIFT;
132  in[4] = (int)(a3 - b3) >> ROW_SHIFT;
133  in[5] = (int)(a2 - b2) >> ROW_SHIFT;
134  in[6] = (int)(a1 - b1) >> ROW_SHIFT;
135  in[7] = (int)(a0 - b0) >> ROW_SHIFT;
136  }
137  return 1;
138 }
139 
140 #define TAN1 0x32EC
141 #define TAN2 0x6A0A
142 #define TAN3 0xAB0E
143 #define SQRT2 0x5A82
144 
145 #define MULT(c, x, n) ((unsigned)((int)((c) * (unsigned)(x)) >> (n)))
146 // 12b version => #define MULT(c,x, n) ((((c) >> 3) * (x)) >> ((n) - 3))
147 // 12b zero-testing version:
148 
149 #define BUTTERFLY(a, b, tmp) \
150  (tmp) = (a) + (b); \
151  (b) = (a) - (b); \
152  (a) = (tmp)
153 
154 #define LOAD_BUTTERFLY(m1, m2, a, b, tmp, s) \
155  (m1) = (s)[(a)] + (s)[(b)]; \
156  (m2) = (s)[(a)] - (s)[(b)]
157 
158 static void idct_col_8(short *const in)
159 {
160  int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, spill;
161 
162  // odd
163 
164  mm4 = (int) in[7 * 8];
165  mm5 = (int) in[5 * 8];
166  mm6 = (int) in[3 * 8];
167  mm7 = (int) in[1 * 8];
168 
169  mm0 = MULT(TAN1, mm4, 16) + mm7;
170  mm1 = MULT(TAN1, mm7, 16) - mm4;
171  mm2 = MULT(TAN3, mm5, 16) + mm6;
172  mm3 = MULT(TAN3, mm6, 16) - mm5;
173 
174  mm7 = mm0 + mm2;
175  mm4 = mm1 - mm3;
176  mm0 = mm0 - mm2;
177  mm1 = mm1 + mm3;
178  mm6 = mm0 + mm1;
179  mm5 = mm0 - mm1;
180  mm5 = 2 * MULT(SQRT2, mm5, 16); // 2*sqrt2
181  mm6 = 2 * MULT(SQRT2, mm6, 16); // Watch out: precision loss but done to match
182  // the pmulhw used in MMX/MMXEXT/SSE2 versions
183 
184  // even
185 
186  mm1 = (int) in[2 * 8];
187  mm2 = (int) in[6 * 8];
188  mm3 = MULT(TAN2, mm2, 16) + mm1;
189  mm2 = MULT(TAN2, mm1, 16) - mm2;
190 
191  LOAD_BUTTERFLY(mm0, mm1, 0 * 8, 4 * 8, spill, in);
192 
193  BUTTERFLY(mm0, mm3, spill);
194  BUTTERFLY(mm0, mm7, spill);
195  in[8 * 0] = (int16_t) (mm0 >> COL_SHIFT);
196  in[8 * 7] = (int16_t) (mm7 >> COL_SHIFT);
197  BUTTERFLY(mm3, mm4, mm0);
198  in[8 * 3] = (int16_t) (mm3 >> COL_SHIFT);
199  in[8 * 4] = (int16_t) (mm4 >> COL_SHIFT);
200 
201  BUTTERFLY(mm1, mm2, mm0);
202  BUTTERFLY(mm1, mm6, mm0);
203  in[8 * 1] = (int16_t) (mm1 >> COL_SHIFT);
204  in[8 * 6] = (int16_t) (mm6 >> COL_SHIFT);
205  BUTTERFLY(mm2, mm5, mm0);
206  in[8 * 2] = (int16_t) (mm2 >> COL_SHIFT);
207  in[8 * 5] = (int16_t) (mm5 >> COL_SHIFT);
208 }
209 
210 static void idct_col_4(short *const in)
211 {
212  int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, spill;
213 
214  // odd
215 
216  mm0 = (int) in[1 * 8];
217  mm2 = (int) in[3 * 8];
218 
219  mm1 = MULT(TAN1, mm0, 16);
220  mm3 = MULT(TAN3, mm2, 16);
221 
222  mm7 = mm0 + mm2;
223  mm4 = mm1 - mm3;
224  mm0 = mm0 - mm2;
225  mm1 = mm1 + mm3;
226  mm6 = mm0 + mm1;
227  mm5 = mm0 - mm1;
228  mm6 = 2 * MULT(SQRT2, mm6, 16); // 2*sqrt2
229  mm5 = 2 * MULT(SQRT2, mm5, 16);
230 
231  // even
232 
233  mm0 = mm1 = (int) in[0 * 8];
234  mm3 = (int) in[2 * 8];
235  mm2 = MULT(TAN2, mm3, 16);
236 
237  BUTTERFLY(mm0, mm3, spill);
238  BUTTERFLY(mm0, mm7, spill);
239  in[8 * 0] = (int16_t) (mm0 >> COL_SHIFT);
240  in[8 * 7] = (int16_t) (mm7 >> COL_SHIFT);
241  BUTTERFLY(mm3, mm4, mm0);
242  in[8 * 3] = (int16_t) (mm3 >> COL_SHIFT);
243  in[8 * 4] = (int16_t) (mm4 >> COL_SHIFT);
244 
245  BUTTERFLY(mm1, mm2, mm0);
246  BUTTERFLY(mm1, mm6, mm0);
247  in[8 * 1] = (int16_t) (mm1 >> COL_SHIFT);
248  in[8 * 6] = (int16_t) (mm6 >> COL_SHIFT);
249  BUTTERFLY(mm2, mm5, mm0);
250  in[8 * 2] = (int16_t) (mm2 >> COL_SHIFT);
251  in[8 * 5] = (int16_t) (mm5 >> COL_SHIFT);
252 }
253 
254 static void idct_col_3(short *const in)
255 {
256  int mm0, mm1, mm2, mm3, mm4, mm5, mm6, mm7, spill;
257 
258  // odd
259 
260  mm7 = (int) in[1 * 8];
261  mm4 = MULT(TAN1, mm7, 16);
262 
263  mm6 = mm7 + mm4;
264  mm5 = mm7 - mm4;
265  mm6 = 2 * MULT(SQRT2, mm6, 16); // 2*sqrt2
266  mm5 = 2 * MULT(SQRT2, mm5, 16);
267 
268  // even
269 
270  mm0 = mm1 = (int) in[0 * 8];
271  mm3 = (int) in[2 * 8];
272  mm2 = MULT(TAN2, mm3, 16);
273 
274  BUTTERFLY(mm0, mm3, spill);
275  BUTTERFLY(mm0, mm7, spill);
276  in[8 * 0] = (int16_t) (mm0 >> COL_SHIFT);
277  in[8 * 7] = (int16_t) (mm7 >> COL_SHIFT);
278  BUTTERFLY(mm3, mm4, mm0);
279  in[8 * 3] = (int16_t) (mm3 >> COL_SHIFT);
280  in[8 * 4] = (int16_t) (mm4 >> COL_SHIFT);
281 
282  BUTTERFLY(mm1, mm2, mm0);
283  BUTTERFLY(mm1, mm6, mm0);
284  in[8 * 1] = (int16_t) (mm1 >> COL_SHIFT);
285  in[8 * 6] = (int16_t) (mm6 >> COL_SHIFT);
286  BUTTERFLY(mm2, mm5, mm0);
287  in[8 * 2] = (int16_t) (mm2 >> COL_SHIFT);
288  in[8 * 5] = (int16_t) (mm5 >> COL_SHIFT);
289 }
290 
291 void ff_xvid_idct(int16_t *const in)
292 {
293  int i, rows = 0x07;
294 
295  idct_row(in + 0 * 8, TAB04, RND0);
296  idct_row(in + 1 * 8, TAB17, RND1);
297  idct_row(in + 2 * 8, TAB26, RND2);
298  if (idct_row(in + 3 * 8, TAB35, RND3))
299  rows |= 0x08;
300  if (idct_row(in + 4 * 8, TAB04, RND4))
301  rows |= 0x10;
302  if (idct_row(in + 5 * 8, TAB35, RND5))
303  rows |= 0x20;
304  if (idct_row(in + 6 * 8, TAB26, RND6))
305  rows |= 0x40;
306  if (idct_row(in + 7 * 8, TAB17, RND7))
307  rows |= 0x80;
308 
309  if (rows & 0xF0) {
310  for (i = 0; i < 8; i++)
311  idct_col_8(in + i);
312  } else if (rows & 0x08) {
313  for (i = 0; i < 8; i++)
314  idct_col_4(in + i);
315  } else {
316  for (i = 0; i < 8; i++)
317  idct_col_3(in + i);
318  }
319 }
320 
321 static void xvid_idct_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
322 {
324  ff_put_pixels_clamped_c(block, dest, line_size);
325 }
326 
327 static void xvid_idct_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
328 {
330  ff_add_pixels_clamped_c(block, dest, line_size);
331 }
332 
334 {
335  const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;
336 
337  if (high_bit_depth || avctx->lowres ||
338  !(avctx->idct_algo == FF_IDCT_AUTO ||
339  avctx->idct_algo == FF_IDCT_XVID))
340  return;
341 
342  if (avctx->idct_algo == FF_IDCT_XVID) {
343  c->idct_put = xvid_idct_put;
344  c->idct_add = xvid_idct_add;
345  c->idct = ff_xvid_idct;
346  c->perm_type = FF_IDCT_PERM_NONE;
347  }
348 
349  if (ARCH_X86)
350  ff_xvid_idct_init_x86(c, avctx, high_bit_depth);
351  if (ARCH_MIPS)
352  ff_xvid_idct_init_mips(c, avctx, high_bit_depth);
353 
354  ff_init_scantable_permutation(c->idct_permutation, c->perm_type);
355 }
RND6
#define RND6
Definition: xvididct.c:49
ff_xvid_idct_init
av_cold void ff_xvid_idct_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: xvididct.c:333
RND2
#define RND2
Definition: xvididct.c:45
xvid_idct_put
static void xvid_idct_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: xvididct.c:321
c1
static const uint64_t c1
Definition: murmur3.c:51
FF_IDCT_AUTO
#define FF_IDCT_AUTO
Definition: avcodec.h:1394
FF_IDCT_XVID
#define FF_IDCT_XVID
Definition: avcodec.h:1401
b1
static double b1(void *priv, double x, double y)
Definition: vf_xfade.c:1665
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
TAN2
#define TAN2
Definition: xvididct.c:141
a1
#define a1
Definition: regdef.h:47
TAN3
#define TAN3
Definition: xvididct.c:142
rnd
#define rnd()
Definition: checkasm.h:120
SQRT2
#define SQRT2
Definition: xvididct.c:143
av_cold
#define av_cold
Definition: attributes.h:90
RND0
#define RND0
Definition: xvididct.c:43
idct_col_3
static void idct_col_3(short *const in)
Definition: xvididct.c:254
b3
static double b3(void *priv, double x, double y)
Definition: vf_xfade.c:1667
idct_col_4
static void idct_col_4(short *const in)
Definition: xvididct.c:210
ff_xvid_idct
void ff_xvid_idct(int16_t *const in)
Definition: xvididct.c:291
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1421
ff_add_pixels_clamped_c
void ff_add_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels, ptrdiff_t line_size)
Definition: idctdsp.c:157
xvididct.h
LOAD_BUTTERFLY
#define LOAD_BUTTERFLY(m1, m2, a, b, tmp, s)
Definition: xvididct.c:154
RND3
#define RND3
Definition: xvididct.c:46
ff_xvid_idct_init_x86
av_cold void ff_xvid_idct_init_x86(IDCTDSPContext *c, AVCodecContext *avctx, unsigned high_bit_depth)
Definition: xvididct_init.c:55
RND5
#define RND5
Definition: xvididct.c:48
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
TAN1
#define TAN1
Definition: xvididct.c:140
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1428
FF_IDCT_PERM_NONE
@ FF_IDCT_PERM_NONE
Definition: idctdsp.h:38
b2
static double b2(void *priv, double x, double y)
Definition: vf_xfade.c:1666
MULT
#define MULT(c, x, n)
Definition: xvididct.c:145
attributes.h
TAB35
static const int TAB35[]
Definition: xvididct.c:55
a0
#define a0
Definition: regdef.h:46
RND7
#define RND7
Definition: xvididct.c:50
ff_put_pixels_clamped_c
void ff_put_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels, ptrdiff_t line_size)
Definition: idctdsp.c:83
TAB26
static const int TAB26[]
Definition: xvididct.c:54
ff_init_scantable_permutation
av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, enum idct_permutation_type perm_type)
Definition: idctdsp.c:50
TAB17
static const int TAB17[]
Definition: xvididct.c:53
ff_xvid_idct_init_mips
av_cold void ff_xvid_idct_init_mips(IDCTDSPContext *c, AVCodecContext *avctx, unsigned high_bit_depth)
Definition: xvididct_init_mips.c:25
i
int i
Definition: input.c:406
idct_col_8
static void idct_col_8(short *const in)
Definition: xvididct.c:158
RND4
#define RND4
Definition: xvididct.c:47
a2
#define a2
Definition: regdef.h:48
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1393
xvid_idct_add
static void xvid_idct_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: xvididct.c:327
TAB04
static const int TAB04[]
Definition: xvididct.c:52
idctdsp.h
avcodec.h
IDCTDSPContext
Definition: idctdsp.h:53
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
RND1
#define RND1
Definition: xvididct.c:44
idct_row
static int idct_row(short *in, const int *const tab, int rnd)
Definition: xvididct.c:57
AVCodecContext
main external API structure.
Definition: avcodec.h:379
c2
static const uint64_t c2
Definition: murmur3.c:52
COL_SHIFT
#define COL_SHIFT
Definition: xvididct.c:40
BUTTERFLY
#define BUTTERFLY(a, b, tmp)
Definition: xvididct.c:149
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
b0
static double b0(void *priv, double x, double y)
Definition: vf_xfade.c:1664
ROW_SHIFT
#define ROW_SHIFT
Definition: xvididct.c:39
int
int
Definition: ffmpeg_filter.c:156
a3
#define a3
Definition: regdef.h:49