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 
41 static av_noinline void FUNC(hl_decode_mb)(H264Context *h)
42 {
43  const int mb_x = h->mb_x;
44  const int mb_y = h->mb_y;
45  const int mb_xy = h->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  int *block_offset = &h->block_offset[0];
51  const int transform_bypass = !SIMPLE && (h->qscale == 0 && h->sps.transform_bypass);
52  /* is_h264 should always be true if SVQ3 is disabled. */
53  const int is_h264 = !CONFIG_SVQ3_DECODER || SIMPLE || h->avctx->codec_id == AV_CODEC_ID_H264;
54  void (*idct_add)(uint8_t *dst, int16_t *block, int stride);
55  const int block_h = 16 >> h->chroma_y_shift;
56  const int chroma422 = CHROMA422(h);
57 
58  dest_y = h->cur_pic.f.data[0] + ((mb_x << PIXEL_SHIFT) + mb_y * h->linesize) * 16;
59  dest_cb = h->cur_pic.f.data[1] + (mb_x << PIXEL_SHIFT) * 8 + mb_y * h->uvlinesize * block_h;
60  dest_cr = h->cur_pic.f.data[2] + (mb_x << PIXEL_SHIFT) * 8 + mb_y * h->uvlinesize * block_h;
61 
62  h->vdsp.prefetch(dest_y + (h->mb_x & 3) * 4 * h->linesize + (64 << PIXEL_SHIFT), h->linesize, 4);
63  h->vdsp.prefetch(dest_cb + (h->mb_x & 7) * h->uvlinesize + (64 << PIXEL_SHIFT), dest_cr - dest_cb, 2);
64 
65  h->list_counts[mb_xy] = h->list_count;
66 
67  if (!SIMPLE && MB_FIELD(h)) {
68  linesize = h->mb_linesize = h->linesize * 2;
69  uvlinesize = h->mb_uvlinesize = h->uvlinesize * 2;
70  block_offset = &h->block_offset[48];
71  if (mb_y & 1) { // FIXME move out of this function?
72  dest_y -= h->linesize * 15;
73  dest_cb -= h->uvlinesize * (block_h - 1);
74  dest_cr -= h->uvlinesize * (block_h - 1);
75  }
76  if (FRAME_MBAFF(h)) {
77  int list;
78  for (list = 0; list < h->list_count; list++) {
79  if (!USES_LIST(mb_type, list))
80  continue;
81  if (IS_16X16(mb_type)) {
82  int8_t *ref = &h->ref_cache[list][scan8[0]];
83  fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (h->mb_y & 1), 1);
84  } else {
85  for (i = 0; i < 16; i += 4) {
86  int ref = h->ref_cache[list][scan8[i]];
87  if (ref >= 0)
88  fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2,
89  8, (16 + ref) ^ (h->mb_y & 1), 1);
90  }
91  }
92  }
93  }
94  } else {
95  linesize = h->mb_linesize = h->linesize;
96  uvlinesize = h->mb_uvlinesize = h->uvlinesize;
97  // dct_offset = s->linesize * 16;
98  }
99 
100  if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
101  const int bit_depth = h->sps.bit_depth_luma;
102  if (PIXEL_SHIFT) {
103  int j;
104  GetBitContext gb;
105  init_get_bits(&gb, h->intra_pcm_ptr,
106  ff_h264_mb_sizes[h->sps.chroma_format_idc] * bit_depth);
107 
108  for (i = 0; i < 16; i++) {
109  uint16_t *tmp_y = (uint16_t *)(dest_y + i * linesize);
110  for (j = 0; j < 16; j++)
111  tmp_y[j] = get_bits(&gb, bit_depth);
112  }
113  if (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
114  if (!h->sps.chroma_format_idc) {
115  for (i = 0; i < block_h; i++) {
116  uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
117  uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
118  for (j = 0; j < 8; j++) {
119  tmp_cb[j] = tmp_cr[j] = 1 << (bit_depth - 1);
120  }
121  }
122  } else {
123  for (i = 0; i < block_h; i++) {
124  uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
125  for (j = 0; j < 8; j++)
126  tmp_cb[j] = get_bits(&gb, bit_depth);
127  }
128  for (i = 0; i < block_h; i++) {
129  uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
130  for (j = 0; j < 8; j++)
131  tmp_cr[j] = get_bits(&gb, bit_depth);
132  }
133  }
134  }
135  } else {
136  for (i = 0; i < 16; i++)
137  memcpy(dest_y + i * linesize, h->intra_pcm_ptr + i * 16, 16);
138  if (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
139  if (!h->sps.chroma_format_idc) {
140  for (i = 0; i < 8; i++) {
141  memset(dest_cb + i*uvlinesize, 1 << (bit_depth - 1), 8);
142  memset(dest_cr + i*uvlinesize, 1 << (bit_depth - 1), 8);
143  }
144  } else {
145  const uint8_t *src_cb = h->intra_pcm_ptr + 256;
146  const uint8_t *src_cr = h->intra_pcm_ptr + 256 + block_h * 8;
147  for (i = 0; i < block_h; i++) {
148  memcpy(dest_cb + i * uvlinesize, src_cb + i * 8, 8);
149  memcpy(dest_cr + i * uvlinesize, src_cr + i * 8, 8);
150  }
151  }
152  }
153  }
154  } else {
155  if (IS_INTRA(mb_type)) {
156  if (h->deblocking_filter)
157  xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize,
158  uvlinesize, 1, 0, SIMPLE, PIXEL_SHIFT);
159 
160  if (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
161  h->hpc.pred8x8[h->chroma_pred_mode](dest_cb, uvlinesize);
162  h->hpc.pred8x8[h->chroma_pred_mode](dest_cr, uvlinesize);
163  }
164 
165  hl_decode_mb_predict_luma(h, mb_type, is_h264, SIMPLE,
166  transform_bypass, PIXEL_SHIFT,
167  block_offset, linesize, dest_y, 0);
168 
169  if (h->deblocking_filter)
170  xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize,
171  uvlinesize, 0, 0, SIMPLE, PIXEL_SHIFT);
172  } else if (is_h264) {
173  if (chroma422) {
174  FUNC(hl_motion_422)(h, dest_y, dest_cb, dest_cr,
175  h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,
176  h->me.qpel_avg, 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, dest_y, dest_cb, dest_cr,
181  h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,
182  h->me.qpel_avg, h->h264chroma.avg_h264_chroma_pixels_tab,
183  h->h264dsp.weight_h264_pixels_tab,
184  h->h264dsp.biweight_h264_pixels_tab);
185  }
186  }
187 
188  hl_decode_mb_idct_luma(h, mb_type, is_h264, SIMPLE, transform_bypass,
189  PIXEL_SHIFT, block_offset, linesize, dest_y, 0);
190 
191  if ((SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) &&
192  (h->cbp & 0x30)) {
193  uint8_t *dest[2] = { dest_cb, dest_cr };
194  if (transform_bypass) {
195  if (IS_INTRA(mb_type) && h->sps.profile_idc == 244 &&
196  (h->chroma_pred_mode == VERT_PRED8x8 ||
197  h->chroma_pred_mode == HOR_PRED8x8)) {
198  h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0],
199  block_offset + 16,
200  h->mb + (16 * 16 * 1 << PIXEL_SHIFT),
201  uvlinesize);
202  h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1],
203  block_offset + 32,
204  h->mb + (16 * 16 * 2 << PIXEL_SHIFT),
205  uvlinesize);
206  } else {
207  idct_add = h->h264dsp.h264_add_pixels4_clear;
208  for (j = 1; j < 3; j++) {
209  for (i = j * 16; i < j * 16 + 4; i++)
210  if (h->non_zero_count_cache[scan8[i]] ||
211  dctcoef_get(h->mb, PIXEL_SHIFT, i * 16))
212  idct_add(dest[j - 1] + block_offset[i],
213  h->mb + (i * 16 << PIXEL_SHIFT),
214  uvlinesize);
215  if (chroma422) {
216  for (i = j * 16 + 4; i < j * 16 + 8; i++)
217  if (h->non_zero_count_cache[scan8[i + 4]] ||
218  dctcoef_get(h->mb, PIXEL_SHIFT, i * 16))
219  idct_add(dest[j - 1] + block_offset[i + 4],
220  h->mb + (i * 16 << PIXEL_SHIFT),
221  uvlinesize);
222  }
223  }
224  }
225  } else {
226  if (is_h264) {
227  int qp[2];
228  if (chroma422) {
229  qp[0] = h->chroma_qp[0] + 3;
230  qp[1] = h->chroma_qp[1] + 3;
231  } else {
232  qp[0] = h->chroma_qp[0];
233  qp[1] = h->chroma_qp[1];
234  }
235  if (h->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 0]])
236  h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16 * 16 * 1 << PIXEL_SHIFT),
237  h->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][qp[0]][0]);
238  if (h->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 1]])
239  h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16 * 16 * 2 << PIXEL_SHIFT),
240  h->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][qp[1]][0]);
241  h->h264dsp.h264_idct_add8(dest, block_offset,
242  h->mb, uvlinesize,
243  h->non_zero_count_cache);
244  } else if (CONFIG_SVQ3_DECODER) {
245  h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16 * 16 * 1,
246  h->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][h->chroma_qp[0]][0]);
247  h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16 * 16 * 2,
248  h->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][h->chroma_qp[1]][0]);
249  for (j = 1; j < 3; j++) {
250  for (i = j * 16; i < j * 16 + 4; i++)
251  if (h->non_zero_count_cache[scan8[i]] || h->mb[i * 16]) {
252  uint8_t *const ptr = dest[j - 1] + block_offset[i];
253  ff_svq3_add_idct_c(ptr, h->mb + i * 16,
254  uvlinesize,
255  ff_h264_chroma_qp[0][h->qscale + 12] - 12, 2);
256  }
257  }
258  }
259  }
260  }
261  }
262 }
263 
264 #if !SIMPLE || BITS == 8
265 
266 #undef CHROMA_IDC
267 #define CHROMA_IDC 3
268 #include "h264_mc_template.c"
269 
270 static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h)
271 {
272  const int mb_x = h->mb_x;
273  const int mb_y = h->mb_y;
274  const int mb_xy = h->mb_xy;
275  const int mb_type = h->cur_pic.mb_type[mb_xy];
276  uint8_t *dest[3];
277  int linesize;
278  int i, j, p;
279  int *block_offset = &h->block_offset[0];
280  const int transform_bypass = !SIMPLE && (h->qscale == 0 && h->sps.transform_bypass);
281  const int plane_count = (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) ? 3 : 1;
282 
283  for (p = 0; p < plane_count; p++) {
284  dest[p] = h->cur_pic.f.data[p] +
285  ((mb_x << PIXEL_SHIFT) + mb_y * h->linesize) * 16;
286  h->vdsp.prefetch(dest[p] + (h->mb_x & 3) * 4 * h->linesize + (64 << PIXEL_SHIFT),
287  h->linesize, 4);
288  }
289 
290  h->list_counts[mb_xy] = h->list_count;
291 
292  if (!SIMPLE && MB_FIELD(h)) {
293  linesize = h->mb_linesize = h->mb_uvlinesize = h->linesize * 2;
294  block_offset = &h->block_offset[48];
295  if (mb_y & 1) // FIXME move out of this function?
296  for (p = 0; p < 3; p++)
297  dest[p] -= h->linesize * 15;
298  if (FRAME_MBAFF(h)) {
299  int list;
300  for (list = 0; list < h->list_count; list++) {
301  if (!USES_LIST(mb_type, list))
302  continue;
303  if (IS_16X16(mb_type)) {
304  int8_t *ref = &h->ref_cache[list][scan8[0]];
305  fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (h->mb_y & 1), 1);
306  } else {
307  for (i = 0; i < 16; i += 4) {
308  int ref = h->ref_cache[list][scan8[i]];
309  if (ref >= 0)
310  fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2,
311  8, (16 + ref) ^ (h->mb_y & 1), 1);
312  }
313  }
314  }
315  }
316  } else {
317  linesize = h->mb_linesize = h->mb_uvlinesize = h->linesize;
318  }
319 
320  if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
321  if (PIXEL_SHIFT) {
322  const int bit_depth = h->sps.bit_depth_luma;
323  GetBitContext gb;
324  init_get_bits(&gb, h->intra_pcm_ptr, 768 * bit_depth);
325 
326  for (p = 0; p < plane_count; p++)
327  for (i = 0; i < 16; i++) {
328  uint16_t *tmp = (uint16_t *)(dest[p] + i * linesize);
329  for (j = 0; j < 16; j++)
330  tmp[j] = get_bits(&gb, bit_depth);
331  }
332  } else {
333  for (p = 0; p < plane_count; p++)
334  for (i = 0; i < 16; i++)
335  memcpy(dest[p] + i * linesize,
336  h->intra_pcm_ptr + p * 256 + i * 16, 16);
337  }
338  } else {
339  if (IS_INTRA(mb_type)) {
340  if (h->deblocking_filter)
341  xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,
342  linesize, 1, 1, SIMPLE, PIXEL_SHIFT);
343 
344  for (p = 0; p < plane_count; p++)
345  hl_decode_mb_predict_luma(h, mb_type, 1, SIMPLE,
346  transform_bypass, PIXEL_SHIFT,
347  block_offset, linesize, dest[p], p);
348 
349  if (h->deblocking_filter)
350  xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,
351  linesize, 0, 1, SIMPLE, PIXEL_SHIFT);
352  } else {
353  FUNC(hl_motion_444)(h, dest[0], dest[1], dest[2],
354  h->me.qpel_put, h->h264chroma.put_h264_chroma_pixels_tab,
355  h->me.qpel_avg, h->h264chroma.avg_h264_chroma_pixels_tab,
356  h->h264dsp.weight_h264_pixels_tab,
357  h->h264dsp.biweight_h264_pixels_tab);
358  }
359 
360  for (p = 0; p < plane_count; p++)
361  hl_decode_mb_idct_luma(h, mb_type, 1, SIMPLE, transform_bypass,
362  PIXEL_SHIFT, block_offset, linesize,
363  dest[p], p);
364  }
365 }
366 
367 #endif
VERT_PRED8x8
#define VERT_PRED8x8
Definition: h264pred.h:70
CONFIG_SVQ3_DECODER
#define CONFIG_SVQ3_DECODER
Definition: config.h:587
H264Context::gb
GetBitContext gb
Definition: h264.h:268
hl_decode_mb_predict_luma
static av_always_inline void hl_decode_mb_predict_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass, int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p)
Definition: h264.c:2272
ref
FIXME Range Coding of cr are ref
Definition: snow.txt:367
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
H264Context::mb_y
int mb_y
Definition: h264.h:461
H264Context
H264Context.
Definition: h264.h:260
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer 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
Definition: filter_design.txt:23
HOR_PRED8x8
#define HOR_PRED8x8
Definition: h264pred.h:69
AV_CODEC_ID_H264
Definition: libavcodec/avcodec.h:130
stride
int stride
Definition: mace.c:144
IS_INTRA_PCM
#define IS_INTRA_PCM(a)
Definition: mpegvideo.h:141
USES_LIST
#define USES_LIST(a, list)
does this mb use listX, note does not work if subMBs
Definition: mpegvideo.h:156
if
initialize output if(nPeaks >3)%at least 3 peaks in spectrum for trying to find f0 nf0peaks
hl_decode_mb_idct_luma
static av_always_inline void hl_decode_mb_idct_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass, int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p)
Definition: h264.c:2387
uint8_t
uint8_t
Definition: audio_convert.c:194
H264Context::mb_xy
int mb_xy
Definition: h264.h:468
hl_decode_mb_444
static av_noinline void FUNC() hl_decode_mb_444(H264Context *h)
Definition: h264_mb_template.c:270
H264Context::uvlinesize
int uvlinesize
Definition: h264.h:283
H264Context::mb_x
int mb_x
Definition: h264.h:461
fill_rectangle
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color, int update)
Definition: ffplay.c:489
ff_h264_chroma_qp
const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1]
One chroma qp table for each possible bit depth (8-14).
Definition: h264_ps.c:75
CHROMA_DC_BLOCK_INDEX
#define CHROMA_DC_BLOCK_INDEX
Definition: h264.h:809
MB_FIELD
#define MB_FIELD(h)
Definition: h264.h:65
IS_INTRA
#define IS_INTRA(a)
Definition: mpegvideo.h:138
scan8
static const uint8_t scan8[16 *3+3]
Definition: h264.h:812
xchg_mb_border
static av_always_inline void xchg_mb_border(H264Context *h, 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.c:2166
ff_svq3_add_idct_c
void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block, int stride, int qp, int dc)
Definition: svq3.c:187
dctcoef_get
static av_always_inline int dctcoef_get(int16_t *mb, int high_bit_depth, int index)
Definition: h264.c:2254
CONFIG_GRAY
#define CONFIG_GRAY
Definition: config.h:376
start.dest
dest
Definition: start.py:60
void
typedef void(RENAME(mix_any_func_type))
Definition: rematrix_template.c:41
idct_add
static void idct_add(uint8_t *dest, int line_size, int16_t *block)
Definition: dsputil_sh4.c:74
CHROMA422
#define CHROMA422(h)
Definition: h264.h:91
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:379
FUNC
#define FUNC(n)
Definition: h264_mb_template.c:29
H264Context::block_offset
int block_offset[2 *(16 *3)]
block_offset[ 0..23] for frame macroblocks block_offset[24..47] for field macroblocks ...
Definition: h264.h:350
hl_decode_mb
static av_noinline void FUNC() hl_decode_mb(H264Context *h)
Definition: h264_mb_template.c:41
SIMPLE
#define SIMPLE
Definition: h264.c:2466
CODEC_FLAG_GRAY
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: libavcodec/avcodec.h:706
H264Context::linesize
int linesize
Definition: h264.h:283
FRAME_MBAFF
#define FRAME_MBAFF(h)
Definition: h264.h:66
ff_h264_mb_sizes
const uint16_t ff_h264_mb_sizes[4]
Definition: h264.c:54
h264_mc_template.c
dst
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
IS_16X16
#define IS_16X16(a)
Definition: mpegvideo.h:145
av_noinline
#define av_noinline
Definition: attributes.h:56
PIXEL_SHIFT
#define PIXEL_SHIFT
Definition: h264_mb_template.c:30
Generated on Fri Dec 20 2024 06:56:01 for FFmpeg by   doxygen 1.8.11