FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
vc1_loopfilter.c
Go to the documentation of this file.
1 /*
2  * VC-1 and WMV3 decoder
3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
4  * Copyright (c) 2006-2007 Konstantin Shishkov
5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * VC-1 and WMV3 loopfilter
27  */
28 
29 #include "avcodec.h"
30 #include "mpegvideo.h"
31 #include "vc1.h"
32 #include "vc1dsp.h"
33 
34 void ff_vc1_loop_filter_iblk(VC1Context *v, int pq)
35 {
36  MpegEncContext *s = &v->s;
37  int j;
38  if (!s->first_slice_line) {
39  v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
40  if (s->mb_x)
41  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
42  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
43  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
44  for (j = 0; j < 2; j++) {
45  v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
46  if (s->mb_x)
47  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
48  }
49  }
50  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
51 
52  if (s->mb_y == s->end_mb_y - 1) {
53  if (s->mb_x) {
54  v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
55  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
56  v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
57  v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
58  }
59  }
60  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
61  }
62 }
63 
64 void ff_vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
65 {
66  MpegEncContext *s = &v->s;
67  int j;
68 
69  /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
70  * means it runs two rows/cols behind the decoding loop. */
71  if (!s->first_slice_line) {
72  if (s->mb_x) {
73  if (s->mb_y >= s->start_mb_y + 2) {
74  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
75 
76  if (s->mb_x >= 2)
77  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
78  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
79  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
80  for (j = 0; j < 2; j++) {
81  v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
82  if (s->mb_x >= 2) {
83  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
84  }
85  }
86  }
87  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
88  }
89 
90  if (s->mb_x == s->mb_width - 1) {
91  if (s->mb_y >= s->start_mb_y + 2) {
92  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
93 
94  if (s->mb_x)
95  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
96  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
97  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
98  for (j = 0; j < 2; j++) {
99  v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
100  if (s->mb_x >= 2) {
101  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
102  }
103  }
104  }
105  v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
106  }
107 
108  if (s->mb_y == s->end_mb_y) {
109  if (s->mb_x) {
110  if (s->mb_x >= 2)
111  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
112  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
113  if (s->mb_x >= 2 && (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))) {
114  for (j = 0; j < 2; j++) {
115  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
116  }
117  }
118  }
119 
120  if (s->mb_x == s->mb_width - 1) {
121  if (s->mb_x)
122  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
123  v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
124  if (s->mb_x && (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))) {
125  for (j = 0; j < 2; j++) {
126  v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
127  }
128  }
129  }
130  }
131  }
132 }
133 
134 void ff_vc1_smooth_overlap_filter_iblk(VC1Context *v)
135 {
136  MpegEncContext *s = &v->s;
137  int mb_pos;
138 
139  if (v->condover == CONDOVER_NONE)
140  return;
141 
142  mb_pos = s->mb_x + s->mb_y * s->mb_stride;
143 
144  /* Within a MB, the horizontal overlap always runs before the vertical.
145  * To accomplish that, we run the H on left and internal borders of the
146  * currently decoded MB. Then, we wait for the next overlap iteration
147  * to do H overlap on the right edge of this MB, before moving over and
148  * running the V overlap. Therefore, the V overlap makes us trail by one
149  * MB col and the H overlap filter makes us trail by one MB row. This
150  * is reflected in the time at which we run the put_pixels loop. */
151  if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
152  if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
153  v->over_flags_plane[mb_pos - 1])) {
154  v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
155  v->block[v->cur_blk_idx][0]);
156  v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
157  v->block[v->cur_blk_idx][2]);
158  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
159  v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
160  v->block[v->cur_blk_idx][4]);
161  v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
162  v->block[v->cur_blk_idx][5]);
163  }
164  }
165  v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
166  v->block[v->cur_blk_idx][1]);
167  v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
168  v->block[v->cur_blk_idx][3]);
169 
170  if (s->mb_x == s->mb_width - 1) {
171  if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
172  v->over_flags_plane[mb_pos - s->mb_stride])) {
173  v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
174  v->block[v->cur_blk_idx][0]);
175  v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
176  v->block[v->cur_blk_idx][1]);
177  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
178  v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
179  v->block[v->cur_blk_idx][4]);
180  v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
181  v->block[v->cur_blk_idx][5]);
182  }
183  }
184  v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
185  v->block[v->cur_blk_idx][2]);
186  v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
187  v->block[v->cur_blk_idx][3]);
188  }
189  }
190  if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
191  if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
192  v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
193  v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
194  v->block[v->left_blk_idx][0]);
195  v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
196  v->block[v->left_blk_idx][1]);
197  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
198  v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
199  v->block[v->left_blk_idx][4]);
200  v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
201  v->block[v->left_blk_idx][5]);
202  }
203  }
204  v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
205  v->block[v->left_blk_idx][2]);
206  v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
207  v->block[v->left_blk_idx][3]);
208  }
209 }
210 
211 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
212 {
213  MpegEncContext *s = &v->s;
214  int mb_cbp = v->cbp[s->mb_x - s->mb_stride],
215  block_cbp = mb_cbp >> (block_num * 4), bottom_cbp,
216  mb_is_intra = v->is_intra[s->mb_x - s->mb_stride],
217  block_is_intra = mb_is_intra >> block_num, bottom_is_intra;
218  int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
219  uint8_t *dst;
220 
221  if (block_num > 3) {
222  dst = s->dest[block_num - 3];
223  } else {
224  dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
225  }
226  if (s->mb_y != s->end_mb_y || block_num < 2) {
227  int16_t (*mv)[2];
228  int mv_stride;
229 
230  if (block_num > 3) {
231  bottom_cbp = v->cbp[s->mb_x] >> (block_num * 4);
232  bottom_is_intra = v->is_intra[s->mb_x] >> block_num;
233  mv = &v->luma_mv[s->mb_x - s->mb_stride];
234  mv_stride = s->mb_stride;
235  } else {
236  bottom_cbp = (block_num < 2) ? (mb_cbp >> ((block_num + 2) * 4))
237  : (v->cbp[s->mb_x] >> ((block_num - 2) * 4));
238  bottom_is_intra = (block_num < 2) ? (mb_is_intra >> (block_num + 2))
239  : (v->is_intra[s->mb_x] >> (block_num - 2));
240  mv_stride = s->b8_stride;
241  mv = &s->current_picture.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
242  }
243 
244  if (bottom_is_intra & 1 || block_is_intra & 1 ||
245  mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
246  v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
247  } else {
248  idx = ((bottom_cbp >> 2) | block_cbp) & 3;
249  if (idx == 3) {
250  v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
251  } else if (idx) {
252  if (idx == 1)
253  v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
254  else
255  v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
256  }
257  }
258  }
259 
260  dst -= 4 * linesize;
261  ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
262  if (ttblk == TT_4X4 || ttblk == TT_8X4) {
263  idx = (block_cbp | (block_cbp >> 2)) & 3;
264  if (idx == 3) {
265  v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
266  } else if (idx) {
267  if (idx == 1)
268  v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
269  else
270  v->vc1dsp.vc1_v_loop_filter4(dst, linesize, v->pq);
271  }
272  }
273 }
274 
275 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
276 {
277  MpegEncContext *s = &v->s;
278  int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
279  block_cbp = mb_cbp >> (block_num * 4), right_cbp,
280  mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
281  block_is_intra = mb_is_intra >> block_num, right_is_intra;
282  int idx, linesize = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
283  uint8_t *dst;
284 
285  if (block_num > 3) {
286  dst = s->dest[block_num - 3] - 8 * linesize;
287  } else {
288  dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
289  }
290 
291  if (s->mb_x != s->mb_width || !(block_num & 5)) {
292  int16_t (*mv)[2];
293 
294  if (block_num > 3) {
295  right_cbp = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
296  right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> block_num;
297  mv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
298  } else {
299  right_cbp = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
300  : (mb_cbp >> ((block_num + 1) * 4));
301  right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> (block_num - 1))
302  : (mb_is_intra >> (block_num + 1));
303  mv = &s->current_picture.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
304  }
305  if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
306  v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
307  } else {
308  idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
309  if (idx == 5) {
310  v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
311  } else if (idx) {
312  if (idx == 1)
313  v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
314  else
315  v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
316  }
317  }
318  }
319 
320  dst -= 4;
321  ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
322  if (ttblk == TT_4X4 || ttblk == TT_4X8) {
323  idx = (block_cbp | (block_cbp >> 1)) & 5;
324  if (idx == 5) {
325  v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
326  } else if (idx) {
327  if (idx == 1)
328  v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
329  else
330  v->vc1dsp.vc1_h_loop_filter4(dst, linesize, v->pq);
331  }
332  }
333 }
334 
335 void ff_vc1_apply_p_loop_filter(VC1Context *v)
336 {
337  MpegEncContext *s = &v->s;
338  int i;
339  int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
340 
341  for (i = 0; i < block_count; i++) {
342  vc1_apply_p_v_loop_filter(v, i);
343  }
344 
345  /* V always precedes H, therefore we run H one MB before V;
346  * at the end of a row, we catch up to complete the row */
347  if (s->mb_x) {
348  for (i = 0; i < block_count; i++) {
349  vc1_apply_p_h_loop_filter(v, i);
350  }
351  if (s->mb_x == s->mb_width - 1) {
352  s->mb_x++;
353  ff_update_block_index(s);
354  for (i = 0; i < block_count; i++) {
355  vc1_apply_p_h_loop_filter(v, i);
356  }
357  }
358  }
359 }
VC1Context::topleft_blk_idx
int topleft_blk_idx
Definition: vc1.h:385
vc1dsp.h
VC-1 and WMV3 decoder.
s
const char * s
Definition: avisynth_c.h:768
ff_vc1_apply_p_loop_filter
void ff_vc1_apply_p_loop_filter(VC1Context *v)
Definition: vc1_loopfilter.c:335
VC1Context
The VC1 Context.
Definition: vc1.h:173
MpegEncContext::start_mb_y
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:150
MpegEncContext::end_mb_y
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:151
ff_vc1_loop_filter_iblk
void ff_vc1_loop_filter_iblk(VC1Context *v, int pq)
Definition: vc1_loopfilter.c:34
mpegvideo.h
mpegvideo header.
VC1Context::top_blk_idx
int top_blk_idx
Definition: vc1.h:385
VC1DSPContext::vc1_v_loop_filter8
void(* vc1_v_loop_filter8)(uint8_t *src, int stride, int pq)
Definition: vc1dsp.h:51
uint8_t
uint8_t
Definition: audio_convert.c:194
VC1DSPContext::vc1_v_loop_filter4
void(* vc1_v_loop_filter4)(uint8_t *src, int stride, int pq)
Definition: vc1dsp.h:49
VC1Context::left_blk_idx
int left_blk_idx
Definition: vc1.h:385
MpegEncContext::current_picture
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:177
VC1Context::luma_mv
int16_t((* luma_mv)[2]
Definition: vc1.h:388
VC1DSPContext::vc1_h_loop_filter8
void(* vc1_h_loop_filter8)(uint8_t *src, int stride, int pq)
Definition: vc1dsp.h:52
VC1Context::over_flags_plane
uint8_t * over_flags_plane
Overflags bitplane.
Definition: vc1.h:323
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:896
ff_update_block_index
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:731
TT_4X4
Definition: vc1.h:119
VC1Context::block
int16_t(* block)[6][64]
Definition: vc1.h:384
vc1_apply_p_h_loop_filter
static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
Definition: vc1_loopfilter.c:275
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1827
VC1DSPContext::vc1_v_loop_filter16
void(* vc1_v_loop_filter16)(uint8_t *src, int stride, int pq)
Definition: vc1dsp.h:53
Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
VC1Context::cbp
uint32_t * cbp
Definition: vc1.h:386
MpegEncContext::block_index
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:293
mv
static const int8_t mv[256][2]
Definition: 4xm.c:77
MpegEncContext::first_slice_line
int first_slice_line
used in MPEG-4 too to handle resync markers
Definition: mpegvideo.h:434
VC1DSPContext::vc1_h_loop_filter4
void(* vc1_h_loop_filter4)(uint8_t *src, int stride, int pq)
Definition: vc1dsp.h:50
avcodec.h
Libavcodec external API header.
MpegEncContext::linesize
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:131
VC1Context::is_intra
uint8_t * is_intra
Definition: vc1.h:387
vc1_apply_p_v_loop_filter
static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
Definition: vc1_loopfilter.c:211
TT_8X4
Definition: vc1.h:115
MpegEncContext::uvlinesize
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:132
MpegEncContext::b8_stride
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:128
VC1Context::s
MpegEncContext s
Definition: vc1.h:174
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:78
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:95
VC1Context::cur_blk_idx
int cur_blk_idx
Definition: vc1.h:385
VC1Context::pq
uint8_t pq
Definition: vc1.h:238
MpegEncContext::mb_stride
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:127
if
if(ret< 0)
Definition: vf_mcdeint.c:282
MpegEncContext::dest
uint8_t * dest[3]
Definition: mpegvideo.h:295
ff_vc1_smooth_overlap_filter_iblk
void ff_vc1_smooth_overlap_filter_iblk(VC1Context *v)
Definition: vc1_loopfilter.c:134
VC1Context::ttblk
int * ttblk
Transform type at the block level.
Definition: vc1.h:259
VC1DSPContext::vc1_v_s_overlap
void(* vc1_v_s_overlap)(int16_t *top, int16_t *bottom)
Definition: vc1dsp.h:47
ff_vc1_loop_filter_iblk_delayed
void ff_vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
Definition: vc1_loopfilter.c:64
VC1Context::condover
uint8_t condover
Definition: vc1.h:325
TT_4X8
Definition: vc1.h:118
av_always_inline
#define av_always_inline
Definition: attributes.h:39
VC1DSPContext::vc1_h_s_overlap
void(* vc1_h_s_overlap)(int16_t *left, int16_t *right)
Definition: vc1dsp.h:48
VC1Context::vc1dsp
VC1DSPContext vc1dsp
Definition: vc1.h:177
VC1DSPContext::vc1_h_loop_filter16
void(* vc1_h_loop_filter16)(uint8_t *src, int stride, int pq)
Definition: vc1dsp.h:54
Generated on Fri Jan 12 2018 01:45:48 for FFmpeg by   doxygen 1.8.6