FFmpeg
mpv_reconstruct_mb_template.c
Go to the documentation of this file.
1 /*
2  * MPEG macroblock reconstruction
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
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 #define NOT_MPEG12 0
24 #define MAY_BE_MPEG12 1
25 #define DEFINITELY_MPEG12 2
26 
27 /* put block[] to dest[] */
28 static inline void put_dct(MpegEncContext *s,
29  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
30 {
31  s->dct_unquantize_intra(s, block, i, qscale);
32  s->idsp.idct_put(dest, line_size, block);
33 }
34 
35 static inline void add_dequant_dct(MpegEncContext *s,
36  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
37 {
38  if (s->block_last_index[i] >= 0) {
39  s->dct_unquantize_inter(s, block, i, qscale);
40 
41  s->idsp.idct_add(dest, line_size, block);
42  }
43 }
44 
45 /* generic function called after a macroblock has been parsed by the
46  decoder or after it has been encoded by the encoder.
47 
48  Important variables used:
49  s->mb_intra : true if intra macroblock
50  s->mv_dir : motion vector direction
51  s->mv_type : motion vector type
52  s->mv : motion vector
53  s->interlaced_dct : true if interlaced dct used (mpeg2)
54  */
55 static av_always_inline
57  int lowres_flag, int is_mpeg12)
58 {
59 #define IS_MPEG12(s) (is_mpeg12 == MAY_BE_MPEG12 ? ((s)->out_format == FMT_MPEG1) : is_mpeg12)
60  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
61 
62  s->current_picture.qscale_table[mb_xy] = s->qscale;
63 
64  /* update DC predictors for P macroblocks */
65  if (!s->mb_intra) {
66  if (is_mpeg12 != DEFINITELY_MPEG12 && (s->h263_pred || s->h263_aic)) {
67  if (s->mbintra_table[mb_xy])
69  } else {
70  s->last_dc[0] =
71  s->last_dc[1] =
72  s->last_dc[2] = 128 << s->intra_dc_precision;
73  }
74  } else if (is_mpeg12 != DEFINITELY_MPEG12 && (s->h263_pred || s->h263_aic))
75  s->mbintra_table[mb_xy] = 1;
76 
77 #if IS_ENCODER
78  if ((s->avctx->flags & AV_CODEC_FLAG_PSNR) || s->frame_skip_threshold || s->frame_skip_factor ||
79  !((s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
80  s->avctx->mb_decision != FF_MB_DECISION_RD)) // FIXME precalc
81 #endif /* IS_ENCODER */
82  {
83  uint8_t *dest_y, *dest_cb, *dest_cr;
84  int dct_linesize, dct_offset;
85  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
86  const int uvlinesize = s->current_picture.f->linesize[1];
87  const int readable = IS_ENCODER || lowres_flag || s->pict_type != AV_PICTURE_TYPE_B;
88  const int block_size = lowres_flag ? 8 >> s->avctx->lowres : 8;
89 
90  /* avoid copy if macroblock skipped in last frame too */
91  /* skip only during decoding as we might trash the buffers during encoding a bit */
92  if (!IS_ENCODER) {
93  uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
94 
95  if (s->mb_skipped) {
96  s->mb_skipped = 0;
97  av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
98  *mbskip_ptr = 1;
99  } else if(!s->current_picture.reference) {
100  *mbskip_ptr = 1;
101  } else{
102  *mbskip_ptr = 0; /* not skipped */
103  }
104  }
105 
106  dct_linesize = linesize << s->interlaced_dct;
107  dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
108 
109  if (readable) {
110  dest_y = s->dest[0];
111  dest_cb = s->dest[1];
112  dest_cr = s->dest[2];
113  } else {
114  dest_y = s->sc.b_scratchpad;
115  dest_cb = s->sc.b_scratchpad + 16 * linesize;
116  dest_cr = s->sc.b_scratchpad + 32 * linesize;
117  }
118 
119  if (!s->mb_intra) {
120  /* motion handling */
121  /* decoding or more than one mb_type (MC was already done otherwise) */
122 
123 #if !IS_ENCODER
124  if (HAVE_THREADS && is_mpeg12 != DEFINITELY_MPEG12 &&
125  s->avctx->active_thread_type & FF_THREAD_FRAME) {
126  if (s->mv_dir & MV_DIR_FORWARD) {
127  ff_thread_await_progress(&s->last_picture_ptr->tf,
128  lowest_referenced_row(s, 0), 0);
129  }
130  if (s->mv_dir & MV_DIR_BACKWARD) {
131  ff_thread_await_progress(&s->next_picture_ptr->tf,
132  lowest_referenced_row(s, 1), 0);
133  }
134  }
135 
136  if (lowres_flag) {
137  const h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
138 
139  if (s->mv_dir & MV_DIR_FORWARD) {
140  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
141  op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
142  }
143  if (s->mv_dir & MV_DIR_BACKWARD) {
144  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
145  }
146  } else {
147  op_pixels_func (*op_pix)[4];
148  qpel_mc_func (*op_qpix)[16];
149 
150  if ((is_mpeg12 == DEFINITELY_MPEG12 || !s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
151  op_pix = s->hdsp.put_pixels_tab;
152  op_qpix = s->qdsp.put_qpel_pixels_tab;
153  } else {
154  op_pix = s->hdsp.put_no_rnd_pixels_tab;
155  op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
156  }
157  if (s->mv_dir & MV_DIR_FORWARD) {
158  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
159  op_pix = s->hdsp.avg_pixels_tab;
160  op_qpix = s->qdsp.avg_qpel_pixels_tab;
161  }
162  if (s->mv_dir & MV_DIR_BACKWARD) {
163  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
164  }
165  }
166 
167  /* skip dequant / idct if we are really late ;) */
168  if (s->avctx->skip_idct) {
169  if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
170  ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
171  || s->avctx->skip_idct >= AVDISCARD_ALL)
172  goto skip_idct;
173  }
174 
175  /* add dct residue */
176  if (!(IS_MPEG12(s) || s->msmpeg4_version ||
177  (s->codec_id == AV_CODEC_ID_MPEG4 && !s->mpeg_quant)))
178 #endif /* !IS_ENCODER */
179  {
180  add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
181  add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
182  add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
183  add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
184 
185  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
186  if (s->chroma_y_shift) {
187  add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
188  add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
189  } else {
190  dct_linesize >>= 1;
191  dct_offset >>= 1;
192  add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
193  add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
194  add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
195  add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
196  }
197  }
198  }
199 #if !IS_ENCODER
200  else if (is_mpeg12 == DEFINITELY_MPEG12 || (s->codec_id != AV_CODEC_ID_WMV2)) {
201  add_dct(s, block[0], 0, dest_y , dct_linesize);
202  add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
203  add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
204  add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
205 
206  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
207  if (s->chroma_y_shift) {//Chroma420
208  add_dct(s, block[4], 4, dest_cb, uvlinesize);
209  add_dct(s, block[5], 5, dest_cr, uvlinesize);
210  } else {
211  //chroma422
212  dct_linesize = uvlinesize << s->interlaced_dct;
213  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
214 
215  add_dct(s, block[4], 4, dest_cb, dct_linesize);
216  add_dct(s, block[5], 5, dest_cr, dct_linesize);
217  add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
218  add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
219  if (!s->chroma_x_shift) {//Chroma444
220  add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
221  add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
222  add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
223  add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
224  }
225  }
226  } //fi gray
227  } else if (CONFIG_WMV2_DECODER) {
228  ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
229  }
230 #endif /* !IS_ENCODER */
231  } else {
232 #if !IS_ENCODER
233  /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
234  TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
235  if (is_mpeg12 != DEFINITELY_MPEG12 && CONFIG_MPEG4_DECODER &&
236  /* s->codec_id == AV_CODEC_ID_MPEG4 && */
237  s->avctx->bits_per_raw_sample > 8) {
238  ff_mpeg4_decode_studio(s, dest_y, dest_cb, dest_cr, block_size,
239  uvlinesize, dct_linesize, dct_offset);
240  } else if (!IS_MPEG12(s))
241 #endif /* !IS_ENCODER */
242  {
243  /* dct only in intra block */
244  put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
245  put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
246  put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
247  put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
248 
249  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
250  if (s->chroma_y_shift) {
251  put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
252  put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
253  } else {
254  dct_offset >>=1;
255  dct_linesize >>=1;
256  put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
257  put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
258  put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
259  put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
260  }
261  }
262  }
263 #if !IS_ENCODER
264  else {
265  s->idsp.idct_put(dest_y, dct_linesize, block[0]);
266  s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
267  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
268  s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
269 
270  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
271  if (s->chroma_y_shift) {
272  s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
273  s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
274  } else {
275  dct_linesize = uvlinesize << s->interlaced_dct;
276  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
277 
278  s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
279  s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
280  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
281  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
282  if (!s->chroma_x_shift) { //Chroma444
283  s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
284  s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
285  s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
286  s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
287  }
288  }
289  } //gray
290  }
291  }
292 skip_idct:
293  if (!readable) {
294  s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y, linesize, 16);
295  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
296  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize, 16 >> s->chroma_y_shift);
297  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize, 16 >> s->chroma_y_shift);
298  }
299 #endif /* !IS_ENCODER */
300  }
301  }
302 }
303 
put_dct
static void put_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpv_reconstruct_mb_template.c:28
h264_chroma_mc_func
void(* h264_chroma_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
Definition: h264chroma.h:25
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
ff_clean_intra_table_entries
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
Definition: mpegvideo.c:827
ff_wmv2_add_mb
void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
Definition: wmv2dec.c:84
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:296
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:262
DEFINITELY_MPEG12
#define DEFINITELY_MPEG12
Definition: mpv_reconstruct_mb_template.c:25
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:70
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:76
mpv_reconstruct_mb_internal
static av_always_inline void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], int lowres_flag, int is_mpeg12)
Definition: mpv_reconstruct_mb_template.c:56
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
op_pixels_func
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
qpel_mc_func
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
add_dct
static void add_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size)
Definition: mpegvideo_dec.c:999
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:75
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:292
IS_MPEG12
#define IS_MPEG12(s)
ff_mpv_motion
void ff_mpv_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t *const *ref_picture, op_pixels_func(*pix_op)[4], qpel_mc_func(*qpix_op)[16])
Definition: mpegvideo_motion.c:815
lowest_referenced_row
static int lowest_referenced_row(MpegEncContext *s, int dir)
find the lowest MB row referenced in the MVs
Definition: mpegvideo_dec.c:963
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1510
add_dequant_dct
static void add_dequant_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpv_reconstruct_mb_template.c:35
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
av_always_inline
#define av_always_inline
Definition: attributes.h:49
MPV_motion_lowres
static void MPV_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t *const *ref_picture, const h264_chroma_mc_func *pix_op)
motion compensation of a single macroblock
Definition: mpegvideo_dec.c:830
ff_mpeg4_decode_studio
void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int block_size, int uvlinesize, int dct_linesize, int dct_offset)
Definition: mpeg4videodec.c:246
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
FF_MB_DECISION_RD
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:907
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:261
IS_ENCODER
#define IS_ENCODER
Definition: mpegvideo_dec.c:1007
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:72
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:70