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_H261 0
24 #define MAY_BE_MPEG12_H261 1
25 #define DEFINITELY_MPEG12_H261 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_H261(s) (is_mpeg12 == MAY_BE_MPEG12_H261 ? ((s)->out_format <= FMT_H261) : is_mpeg12)
60  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
61 
62  s->cur_pic.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_H261 && (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_H261 && (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 = s->dest[0], *dest_cb = s->dest[1], *dest_cr = s->dest[2];
84  int dct_linesize, dct_offset;
85  const int linesize = s->cur_pic.linesize[0]; //not s->linesize as this would be wrong for field pics
86  const int uvlinesize = s->cur_pic.linesize[1];
87  const int block_size = lowres_flag ? 8 >> s->avctx->lowres : 8;
88 
89  /* avoid copy if macroblock skipped in last frame too */
90  /* skip only during decoding as we might trash the buffers during encoding a bit */
91  if (!IS_ENCODER) {
92  uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
93 
94  if (s->mb_skipped) {
95  s->mb_skipped = 0;
96  av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
97  *mbskip_ptr = 1;
98  } else if (!s->cur_pic.reference) {
99  *mbskip_ptr = 1;
100  } else{
101  *mbskip_ptr = 0; /* not skipped */
102  }
103  }
104 
105  dct_linesize = linesize << s->interlaced_dct;
106  dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
107 
108  if (!s->mb_intra) {
109  /* motion handling */
110  /* decoding or more than one mb_type (MC was already done otherwise) */
111 
112 #if !IS_ENCODER
113  if (HAVE_THREADS && is_mpeg12 != DEFINITELY_MPEG12_H261 &&
114  s->avctx->active_thread_type & FF_THREAD_FRAME) {
115  if (s->mv_dir & MV_DIR_FORWARD) {
116  ff_thread_progress_await(&s->last_pic.ptr->progress,
118  }
119  if (s->mv_dir & MV_DIR_BACKWARD) {
120  ff_thread_progress_await(&s->next_pic.ptr->progress,
122  }
123  }
124 
125  if (lowres_flag) {
126  const h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
127 
128  if (s->mv_dir & MV_DIR_FORWARD) {
129  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_pic.data, op_pix);
130  op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
131  }
132  if (s->mv_dir & MV_DIR_BACKWARD) {
133  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_pic.data, op_pix);
134  }
135  } else {
136  const op_pixels_func (*op_pix)[4];
137  const qpel_mc_func (*op_qpix)[16];
138 
139  if ((is_mpeg12 == DEFINITELY_MPEG12_H261 || !s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
140  op_pix = s->hdsp.put_pixels_tab;
141  op_qpix = s->qdsp.put_qpel_pixels_tab;
142  } else {
143  op_pix = s->hdsp.put_no_rnd_pixels_tab;
144  op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
145  }
146  if (s->mv_dir & MV_DIR_FORWARD) {
147  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_pic.data, op_pix, op_qpix);
148  op_pix = s->hdsp.avg_pixels_tab;
149  op_qpix = s->qdsp.avg_qpel_pixels_tab;
150  }
151  if (s->mv_dir & MV_DIR_BACKWARD) {
152  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_pic.data, op_pix, op_qpix);
153  }
154  }
155 
156  /* skip dequant / idct if we are really late ;) */
157  if (s->avctx->skip_idct) {
158  if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
159  ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
160  || s->avctx->skip_idct >= AVDISCARD_ALL)
161  return;
162  }
163 
164  /* add dct residue */
165  if (!(IS_MPEG12_H261(s) || s->msmpeg4_version != MSMP4_UNUSED ||
166  (s->codec_id == AV_CODEC_ID_MPEG4 && !s->mpeg_quant)))
167 #endif /* !IS_ENCODER */
168  {
169  add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
170  add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
171  add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
172  add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
173 
174  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
175  av_assert2(IS_ENCODER || s->chroma_y_shift);
176  if (!IS_ENCODER || s->chroma_y_shift) {
177  add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
178  add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
179  } else {
180  dct_linesize >>= 1;
181  dct_offset >>= 1;
182  add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
183  add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
184  add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
185  add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
186  }
187  }
188  }
189 #if !IS_ENCODER
190  else if (is_mpeg12 == DEFINITELY_MPEG12_H261 || lowres_flag || (s->codec_id != AV_CODEC_ID_WMV2)) {
191  add_dct(s, block[0], 0, dest_y , dct_linesize);
192  add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
193  add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
194  add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
195 
196  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
197  if (s->chroma_y_shift) {//Chroma420
198  add_dct(s, block[4], 4, dest_cb, uvlinesize);
199  add_dct(s, block[5], 5, dest_cr, uvlinesize);
200  } else {
201  //chroma422
202  dct_linesize = uvlinesize << s->interlaced_dct;
203  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
204 
205  add_dct(s, block[4], 4, dest_cb, dct_linesize);
206  add_dct(s, block[5], 5, dest_cr, dct_linesize);
207  add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
208  add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
209  if (!s->chroma_x_shift) {//Chroma444
210  add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
211  add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
212  add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
213  add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
214  }
215  }
216  } //fi gray
217  } else if (CONFIG_WMV2_DECODER) {
218  ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
219  }
220 #endif /* !IS_ENCODER */
221  } else {
222 #if !IS_ENCODER
223  /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
224  TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
225  if (is_mpeg12 != DEFINITELY_MPEG12_H261 && CONFIG_MPEG4_DECODER &&
226  /* s->codec_id == AV_CODEC_ID_MPEG4 && */
227  s->avctx->bits_per_raw_sample > 8) {
228  ff_mpeg4_decode_studio(s, dest_y, dest_cb, dest_cr, block_size,
229  uvlinesize, dct_linesize, dct_offset);
230  } else if (!IS_MPEG12_H261(s))
231 #endif /* !IS_ENCODER */
232  {
233  /* dct only in intra block */
234  put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
235  put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
236  put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
237  put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
238 
239  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
240  if (s->chroma_y_shift) {
241  put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
242  put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
243  } else {
244  dct_offset >>=1;
245  dct_linesize >>=1;
246  put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
247  put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
248  put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
249  put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
250  }
251  }
252  }
253 #if !IS_ENCODER
254  else {
255  s->idsp.idct_put(dest_y, dct_linesize, block[0]);
256  s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
257  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
258  s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
259 
260  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
261  if (s->chroma_y_shift) {
262  s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
263  s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
264  } else {
265  dct_linesize = uvlinesize << s->interlaced_dct;
266  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
267 
268  s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
269  s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
270  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
271  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
272  if (!s->chroma_x_shift) { //Chroma444
273  s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
274  s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
275  s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
276  s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
277  }
278  }
279  } //gray
280  }
281 #endif /* !IS_ENCODER */
282  }
283  }
284 }
285 
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
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, const op_pixels_func(*pix_op)[4], const qpel_mc_func(*qpix_op)[16])
Definition: mpegvideo_motion.c:819
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
IS_MPEG12_H261
#define IS_MPEG12_H261(s)
ff_clean_intra_table_entries
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac for the current non-intra MB.
Definition: mpegvideo.c:799
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:85
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:326
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:262
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:70
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:220
ff_thread_progress_await
void ff_thread_progress_await(const ThreadProgress *pro_c, int n)
This function is a no-op in no-op mode; otherwise it waits until other threads have reached a certain...
Definition: threadprogress.c:65
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:279
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:899
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:219
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
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:863
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1594
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:67
DEFINITELY_MPEG12_H261
#define DEFINITELY_MPEG12_H261
Definition: mpv_reconstruct_mb_template.c:25
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:731
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:247
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
FF_MB_DECISION_RD
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:965
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:261
IS_ENCODER
#define IS_ENCODER
Definition: mpegvideo_dec.c:907
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:216
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73