FFmpeg
h264_mb_template.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... decoder
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #undef FUNC
23 #undef PIXEL_SHIFT
24 
25 #if SIMPLE
26 # define FUNC(n) AV_JOIN(n ## _simple_, BITS)
27 # define PIXEL_SHIFT (BITS >> 4)
28 #else
29 # define FUNC(n) n ## _complex
30 # define PIXEL_SHIFT h->pixel_shift
31 #endif
32 
33 #undef CHROMA_IDC
34 #define CHROMA_IDC 1
35 #include "h264_mc_template.c"
36 
37 #undef CHROMA_IDC
38 #define CHROMA_IDC 2
39 #include "h264_mc_template.c"
40 
42 {
43  const int mb_x = sl->mb_x;
44  const int mb_y = sl->mb_y;
45  const int mb_xy = sl->mb_xy;
46  const int mb_type = h->cur_pic.mb_type[mb_xy];
47  uint8_t *dest_y, *dest_cb, *dest_cr;
48  int linesize, uvlinesize /*dct_offset*/;
49  int i, j;
50  const int *block_offset = &h->block_offset[0];
51  const int transform_bypass = !SIMPLE && (sl->qscale == 0 && h->ps.sps->transform_bypass);
52  void (*idct_add)(uint8_t *dst, int16_t *block, int stride);
53  const int block_h = 16 >> h->chroma_y_shift;
54  const int chroma422 = CHROMA422(h);
55 
56  dest_y = h->cur_pic.f->data[0] + ((mb_x << PIXEL_SHIFT) + mb_y * sl->linesize) * 16;
57  dest_cb = h->cur_pic.f->data[1] + (mb_x << PIXEL_SHIFT) * 8 + mb_y * sl->uvlinesize * block_h;
58  dest_cr = h->cur_pic.f->data[2] + (mb_x << PIXEL_SHIFT) * 8 + mb_y * sl->uvlinesize * block_h;
59 
60  h->vdsp.prefetch(dest_y + (sl->mb_x & 3) * 4 * sl->linesize + (64 << PIXEL_SHIFT), sl->linesize, 4);
61  h->vdsp.prefetch(dest_cb + (sl->mb_x & 7) * sl->uvlinesize + (64 << PIXEL_SHIFT), dest_cr - dest_cb, 2);
62 
63  h->list_counts[mb_xy] = sl->list_count;
64 
65  if (!SIMPLE && MB_FIELD(sl)) {
66  linesize = sl->mb_linesize = sl->linesize * 2;
67  uvlinesize = sl->mb_uvlinesize = sl->uvlinesize * 2;
68  block_offset = &h->block_offset[48];
69  if (mb_y & 1) { // FIXME move out of this function?
70  dest_y -= sl->linesize * 15;
71  dest_cb -= sl->uvlinesize * (block_h - 1);
72  dest_cr -= sl->uvlinesize * (block_h - 1);
73  }
74  if (FRAME_MBAFF(h)) {
75  int list;
76  for (list = 0; list < sl->list_count; list++) {
77  if (!USES_LIST(mb_type, list))
78  continue;
79  if (IS_16X16(mb_type)) {
80  int8_t *ref = &sl->ref_cache[list][scan8[0]];
81  fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (sl->mb_y & 1), 1);
82  } else {
83  for (i = 0; i < 16; i += 4) {
84  int ref = sl->ref_cache[list][scan8[i]];
85  if (ref >= 0)
86  fill_rectangle(&sl->ref_cache[list][scan8[i]], 2, 2,
87  8, (16 + ref) ^ (sl->mb_y & 1), 1);
88  }
89  }
90  }
91  }
92  } else {
93  linesize = sl->mb_linesize = sl->linesize;
94  uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
95  // dct_offset = s->linesize * 16;
96  }
97 
98  if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
99  const int bit_depth = h->ps.sps->bit_depth_luma;
100  if (PIXEL_SHIFT) {
101  int j;
102  GetBitContext gb;
103  init_get_bits(&gb, sl->intra_pcm_ptr,
104  ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] * bit_depth);
105 
106  for (i = 0; i < 16; i++) {
107  uint16_t *tmp_y = (uint16_t *)(dest_y + i * linesize);
108  for (j = 0; j < 16; j++)
109  tmp_y[j] = get_bits(&gb, bit_depth);
110  }
111  if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
112  if (!h->ps.sps->chroma_format_idc) {
113  for (i = 0; i < block_h; i++) {
114  uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
115  uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
116  for (j = 0; j < 8; j++) {
117  tmp_cb[j] = tmp_cr[j] = 1 << (bit_depth - 1);
118  }
119  }
120  } else {
121  for (i = 0; i < block_h; i++) {
122  uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
123  for (j = 0; j < 8; j++)
124  tmp_cb[j] = get_bits(&gb, bit_depth);
125  }
126  for (i = 0; i < block_h; i++) {
127  uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
128  for (j = 0; j < 8; j++)
129  tmp_cr[j] = get_bits(&gb, bit_depth);
130  }
131  }
132  }
133  } else {
134  for (i = 0; i < 16; i++)
135  memcpy(dest_y + i * linesize, sl->intra_pcm_ptr + i * 16, 16);
136  if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
137  if (!h->ps.sps->chroma_format_idc) {
138  for (i = 0; i < 8; i++) {
139  memset(dest_cb + i * uvlinesize, 1 << (bit_depth - 1), 8);
140  memset(dest_cr + i * uvlinesize, 1 << (bit_depth - 1), 8);
141  }
142  } else {
143  const uint8_t *src_cb = sl->intra_pcm_ptr + 256;
144  const uint8_t *src_cr = sl->intra_pcm_ptr + 256 + block_h * 8;
145  for (i = 0; i < block_h; i++) {
146  memcpy(dest_cb + i * uvlinesize, src_cb + i * 8, 8);
147  memcpy(dest_cr + i * uvlinesize, src_cr + i * 8, 8);
148  }
149  }
150  }
151  }
152  } else {
153  if (IS_INTRA(mb_type)) {
154  if (sl->deblocking_filter)
155  xchg_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
156  uvlinesize, 1, 0, SIMPLE, PIXEL_SHIFT);
157 
158  if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
159  h->hpc.pred8x8[sl->chroma_pred_mode](dest_cb, uvlinesize);
160  h->hpc.pred8x8[sl->chroma_pred_mode](dest_cr, uvlinesize);
161  }
162 
163  hl_decode_mb_predict_luma(h, sl, mb_type, SIMPLE,
164  transform_bypass, PIXEL_SHIFT,
165  block_offset, linesize, dest_y, 0);
166 
167  if (sl->deblocking_filter)
168  xchg_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
169  uvlinesize, 0, 0, SIMPLE, PIXEL_SHIFT);
170  } else {
171  if (chroma422) {
172  FUNC(hl_motion_422)(h, sl, dest_y, dest_cb, dest_cr,
173  h->h264qpel.put_h264_qpel_pixels_tab,
174  h->h264chroma.put_h264_chroma_pixels_tab,
175  h->h264qpel.avg_h264_qpel_pixels_tab,
176  h->h264chroma.avg_h264_chroma_pixels_tab,
177  h->h264dsp.weight_h264_pixels_tab,
178  h->h264dsp.biweight_h264_pixels_tab);
179  } else {
180  FUNC(hl_motion_420)(h, sl, dest_y, dest_cb, dest_cr,
181  h->h264qpel.put_h264_qpel_pixels_tab,
182  h->h264chroma.put_h264_chroma_pixels_tab,
183  h->h264qpel.avg_h264_qpel_pixels_tab,
184  h->h264chroma.avg_h264_chroma_pixels_tab,
185  h->h264dsp.weight_h264_pixels_tab,
186  h->h264dsp.biweight_h264_pixels_tab);
187  }
188  }
189 
190  hl_decode_mb_idct_luma(h, sl, mb_type, SIMPLE, transform_bypass,
191  PIXEL_SHIFT, block_offset, linesize, dest_y, 0);
192 
193  if ((SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) &&
194  (sl->cbp & 0x30)) {
195  uint8_t *dest[2] = { dest_cb, dest_cr };
196  if (transform_bypass) {
197  if (IS_INTRA(mb_type) && h->ps.sps->profile_idc == 244 &&
198  (sl->chroma_pred_mode == VERT_PRED8x8 ||
199  sl->chroma_pred_mode == HOR_PRED8x8)) {
200  h->hpc.pred8x8_add[sl->chroma_pred_mode](dest[0],
201  block_offset + 16,
202  sl->mb + (16 * 16 * 1 << PIXEL_SHIFT),
203  uvlinesize);
204  h->hpc.pred8x8_add[sl->chroma_pred_mode](dest[1],
205  block_offset + 32,
206  sl->mb + (16 * 16 * 2 << PIXEL_SHIFT),
207  uvlinesize);
208  } else {
209  idct_add = h->h264dsp.h264_add_pixels4_clear;
210  for (j = 1; j < 3; j++) {
211  for (i = j * 16; i < j * 16 + 4; i++)
212  if (sl->non_zero_count_cache[scan8[i]] ||
213  dctcoef_get(sl->mb, PIXEL_SHIFT, i * 16))
214  idct_add(dest[j - 1] + block_offset[i],
215  sl->mb + (i * 16 << PIXEL_SHIFT),
216  uvlinesize);
217  if (chroma422) {
218  for (i = j * 16 + 4; i < j * 16 + 8; i++)
219  if (sl->non_zero_count_cache[scan8[i + 4]] ||
220  dctcoef_get(sl->mb, PIXEL_SHIFT, i * 16))
221  idct_add(dest[j - 1] + block_offset[i + 4],
222  sl->mb + (i * 16 << PIXEL_SHIFT),
223  uvlinesize);
224  }
225  }
226  }
227  } else {
228  int qp[2];
229  if (chroma422) {
230  qp[0] = sl->chroma_qp[0] + 3;
231  qp[1] = sl->chroma_qp[1] + 3;
232  } else {
233  qp[0] = sl->chroma_qp[0];
234  qp[1] = sl->chroma_qp[1];
235  }
236  if (sl->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 0]])
237  h->h264dsp.h264_chroma_dc_dequant_idct(sl->mb + (16 * 16 * 1 << PIXEL_SHIFT),
238  h->ps.pps->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][qp[0]][0]);
239  if (sl->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 1]])
240  h->h264dsp.h264_chroma_dc_dequant_idct(sl->mb + (16 * 16 * 2 << PIXEL_SHIFT),
241  h->ps.pps->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][qp[1]][0]);
242  h->h264dsp.h264_idct_add8(dest, block_offset,
243  sl->mb, uvlinesize,
244  sl->non_zero_count_cache);
245  }
246  }
247  }
248 }
249 
250 #if !SIMPLE || BITS == 8
251 
252 #undef CHROMA_IDC
253 #define CHROMA_IDC 3
254 #include "h264_mc_template.c"
255 
257 {
258  const int mb_x = sl->mb_x;
259  const int mb_y = sl->mb_y;
260  const int mb_xy = sl->mb_xy;
261  const int mb_type = h->cur_pic.mb_type[mb_xy];
262  uint8_t *dest[3];
263  int linesize;
264  int i, j, p;
265  const int *block_offset = &h->block_offset[0];
266  const int transform_bypass = !SIMPLE && (sl->qscale == 0 && h->ps.sps->transform_bypass);
267  const int plane_count = (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) ? 3 : 1;
268 
269  for (p = 0; p < plane_count; p++) {
270  dest[p] = h->cur_pic.f->data[p] +
271  ((mb_x << PIXEL_SHIFT) + mb_y * sl->linesize) * 16;
272  h->vdsp.prefetch(dest[p] + (sl->mb_x & 3) * 4 * sl->linesize + (64 << PIXEL_SHIFT),
273  sl->linesize, 4);
274  }
275 
276  h->list_counts[mb_xy] = sl->list_count;
277 
278  if (!SIMPLE && MB_FIELD(sl)) {
279  linesize = sl->mb_linesize = sl->mb_uvlinesize = sl->linesize * 2;
280  block_offset = &h->block_offset[48];
281  if (mb_y & 1) // FIXME move out of this function?
282  for (p = 0; p < 3; p++)
283  dest[p] -= sl->linesize * 15;
284  if (FRAME_MBAFF(h)) {
285  int list;
286  for (list = 0; list < sl->list_count; list++) {
287  if (!USES_LIST(mb_type, list))
288  continue;
289  if (IS_16X16(mb_type)) {
290  int8_t *ref = &sl->ref_cache[list][scan8[0]];
291  fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (sl->mb_y & 1), 1);
292  } else {
293  for (i = 0; i < 16; i += 4) {
294  int ref = sl->ref_cache[list][scan8[i]];
295  if (ref >= 0)
296  fill_rectangle(&sl->ref_cache[list][scan8[i]], 2, 2,
297  8, (16 + ref) ^ (sl->mb_y & 1), 1);
298  }
299  }
300  }
301  }
302  } else {
303  linesize = sl->mb_linesize = sl->mb_uvlinesize = sl->linesize;
304  }
305 
306  if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
307  if (PIXEL_SHIFT) {
308  const int bit_depth = h->ps.sps->bit_depth_luma;
309  GetBitContext gb;
310  init_get_bits(&gb, sl->intra_pcm_ptr, 768 * bit_depth);
311 
312  for (p = 0; p < plane_count; p++)
313  for (i = 0; i < 16; i++) {
314  uint16_t *tmp = (uint16_t *)(dest[p] + i * linesize);
315  for (j = 0; j < 16; j++)
316  tmp[j] = get_bits(&gb, bit_depth);
317  }
318  } else {
319  for (p = 0; p < plane_count; p++)
320  for (i = 0; i < 16; i++)
321  memcpy(dest[p] + i * linesize,
322  sl->intra_pcm_ptr + p * 256 + i * 16, 16);
323  }
324  } else {
325  if (IS_INTRA(mb_type)) {
326  if (sl->deblocking_filter)
327  xchg_mb_border(h, sl, dest[0], dest[1], dest[2], linesize,
328  linesize, 1, 1, SIMPLE, PIXEL_SHIFT);
329 
330  for (p = 0; p < plane_count; p++)
331  hl_decode_mb_predict_luma(h, sl, mb_type, SIMPLE,
332  transform_bypass, PIXEL_SHIFT,
333  block_offset, linesize, dest[p], p);
334 
335  if (sl->deblocking_filter)
336  xchg_mb_border(h, sl, dest[0], dest[1], dest[2], linesize,
337  linesize, 0, 1, SIMPLE, PIXEL_SHIFT);
338  } else {
339  FUNC(hl_motion_444)(h, sl, dest[0], dest[1], dest[2],
340  h->h264qpel.put_h264_qpel_pixels_tab,
341  h->h264chroma.put_h264_chroma_pixels_tab,
342  h->h264qpel.avg_h264_qpel_pixels_tab,
343  h->h264chroma.avg_h264_chroma_pixels_tab,
344  h->h264dsp.weight_h264_pixels_tab,
345  h->h264dsp.biweight_h264_pixels_tab);
346  }
347 
348  for (p = 0; p < plane_count; p++)
349  hl_decode_mb_idct_luma(h, sl, mb_type, SIMPLE, transform_bypass,
350  PIXEL_SHIFT, block_offset, linesize,
351  dest[p], p);
352  }
353 }
354 
355 #endif
#define VERT_PRED8x8
Definition: h264pred.h:70
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
H264Context.
Definition: h264dec.h:337
#define HOR_PRED8x8
Definition: h264pred.h:69
#define USES_LIST(a, list)
Definition: mpegutils.h:99
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define MB_FIELD(sl)
Definition: h264dec.h:72
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:883
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define IS_INTRA_PCM(a)
Definition: mpegutils.h:82
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
static av_always_inline void hl_decode_mb_idct_luma(const H264Context *h, H264SliceContext *sl, int mb_type, int simple, int transform_bypass, int pixel_shift, const int *block_offset, int linesize, uint8_t *dest_y, int p)
Definition: h264_mb.c:727
#define CHROMA_DC_BLOCK_INDEX
Definition: h264dec.h:641
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:827
if(ret)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
static av_always_inline int dctcoef_get(int16_t *mb, int high_bit_depth, int index)
Definition: h264_mb.c:595
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:644
#define IS_16X16(a)
Definition: mpegutils.h:86
#define FRAME_MBAFF(h)
Definition: h264dec.h:73
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#define FUNC(n)
static av_always_inline void xchg_mb_border(const H264Context *h, H264SliceContext *sl, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg, int chroma444, int simple, int pixel_shift)
Definition: h264_mb.c:508
static av_always_inline void hl_decode_mb_predict_luma(const H264Context *h, H264SliceContext *sl, int mb_type, int simple, int transform_bypass, int pixel_shift, const int *block_offset, int linesize, uint8_t *dest_y, int p)
Definition: h264_mb.c:613
#define SIMPLE
Definition: h264_mb.c:796
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
static av_noinline void FUNC() hl_decode_mb(const H264Context *h, H264SliceContext *sl)
#define IS_INTRA(x, y)
#define CHROMA422(h)
Definition: h264dec.h:98
#define av_noinline
Definition: attributes.h:62
#define stride
static av_noinline void FUNC() hl_decode_mb_444(const H264Context *h, H264SliceContext *sl)
#define PIXEL_SHIFT
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:58
static uint8_t tmp[11]
Definition: aes_ctr.c:26