FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
h263.c
Go to the documentation of this file.
1 /*
2  * H.263/MPEG-4 backend for encoder and decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * H.263+ support.
5  * Copyright (c) 2001 Juan J. Sierralta P
6  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * H.263/MPEG-4 codec.
28  */
29 
30 #include <limits.h>
31 
32 #include "avcodec.h"
33 #include "mpegvideo.h"
34 #include "h263.h"
35 #include "h263data.h"
36 #include "mathops.h"
37 #include "mpegutils.h"
38 #include "flv.h"
39 #include "mpeg4video.h"
40 
41 
43  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
44  //FIXME a lot of that is only needed for !low_delay
45  const int wrap = s->b8_stride;
46  const int xy = s->block_index[0];
47 
49 
50  if(s->mv_type != MV_TYPE_8X8){
51  int motion_x, motion_y;
52  if (s->mb_intra) {
53  motion_x = 0;
54  motion_y = 0;
55  } else if (s->mv_type == MV_TYPE_16X16) {
56  motion_x = s->mv[0][0][0];
57  motion_y = s->mv[0][0][1];
58  } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
59  int i;
60  motion_x = s->mv[0][0][0] + s->mv[0][1][0];
61  motion_y = s->mv[0][0][1] + s->mv[0][1][1];
62  motion_x = (motion_x>>1) | (motion_x&1);
63  for(i=0; i<2; i++){
64  s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
65  s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
66  }
67  s->current_picture.ref_index[0][4*mb_xy ] =
68  s->current_picture.ref_index[0][4*mb_xy + 1] = s->field_select[0][0];
69  s->current_picture.ref_index[0][4*mb_xy + 2] =
70  s->current_picture.ref_index[0][4*mb_xy + 3] = s->field_select[0][1];
71  }
72 
73  /* no update if 8X8 because it has been done during parsing */
74  s->current_picture.motion_val[0][xy][0] = motion_x;
75  s->current_picture.motion_val[0][xy][1] = motion_y;
76  s->current_picture.motion_val[0][xy + 1][0] = motion_x;
77  s->current_picture.motion_val[0][xy + 1][1] = motion_y;
78  s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
79  s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
80  s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
81  s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
82  }
83 
84  if(s->encoding){ //FIXME encoding MUST be cleaned up
85  if (s->mv_type == MV_TYPE_8X8)
87  else if(s->mb_intra)
89  else
91  }
92 }
93 
94 int ff_h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
95 {
96  int x, y, wrap, a, c, pred_dc;
97  int16_t *dc_val;
98 
99  /* find prediction */
100  if (n < 4) {
101  x = 2 * s->mb_x + (n & 1);
102  y = 2 * s->mb_y + ((n & 2) >> 1);
103  wrap = s->b8_stride;
104  dc_val = s->dc_val[0];
105  } else {
106  x = s->mb_x;
107  y = s->mb_y;
108  wrap = s->mb_stride;
109  dc_val = s->dc_val[n - 4 + 1];
110  }
111  /* B C
112  * A X
113  */
114  a = dc_val[(x - 1) + (y) * wrap];
115  c = dc_val[(x) + (y - 1) * wrap];
116 
117  /* No prediction outside GOB boundary */
118  if(s->first_slice_line && n!=3){
119  if(n!=2) c= 1024;
120  if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
121  }
122  /* just DC prediction */
123  if (a != 1024 && c != 1024)
124  pred_dc = (a + c) >> 1;
125  else if (a != 1024)
126  pred_dc = a;
127  else
128  pred_dc = c;
129 
130  /* we assume pred is positive */
131  *dc_val_ptr = &dc_val[x + y * wrap];
132  return pred_dc;
133 }
134 
136  int qp_c;
137  const int linesize = s->linesize;
138  const int uvlinesize= s->uvlinesize;
139  const int xy = s->mb_y * s->mb_stride + s->mb_x;
140  uint8_t *dest_y = s->dest[0];
141  uint8_t *dest_cb= s->dest[1];
142  uint8_t *dest_cr= s->dest[2];
143 
144 // if(s->pict_type==AV_PICTURE_TYPE_B && !s->readable) return;
145 
146  /*
147  Diag Top
148  Left Center
149  */
150  if (!IS_SKIP(s->current_picture.mb_type[xy])) {
151  qp_c= s->qscale;
152  s->h263dsp.h263_v_loop_filter(dest_y + 8 * linesize, linesize, qp_c);
153  s->h263dsp.h263_v_loop_filter(dest_y + 8 * linesize + 8, linesize, qp_c);
154  }else
155  qp_c= 0;
156 
157  if(s->mb_y){
158  int qp_dt, qp_tt, qp_tc;
159 
160  if (IS_SKIP(s->current_picture.mb_type[xy - s->mb_stride]))
161  qp_tt=0;
162  else
163  qp_tt = s->current_picture.qscale_table[xy - s->mb_stride];
164 
165  if(qp_c)
166  qp_tc= qp_c;
167  else
168  qp_tc= qp_tt;
169 
170  if(qp_tc){
171  const int chroma_qp= s->chroma_qscale_table[qp_tc];
172  s->h263dsp.h263_v_loop_filter(dest_y, linesize, qp_tc);
173  s->h263dsp.h263_v_loop_filter(dest_y + 8, linesize, qp_tc);
174 
175  s->h263dsp.h263_v_loop_filter(dest_cb, uvlinesize, chroma_qp);
176  s->h263dsp.h263_v_loop_filter(dest_cr, uvlinesize, chroma_qp);
177  }
178 
179  if(qp_tt)
180  s->h263dsp.h263_h_loop_filter(dest_y - 8 * linesize + 8, linesize, qp_tt);
181 
182  if(s->mb_x){
183  if (qp_tt || IS_SKIP(s->current_picture.mb_type[xy - 1 - s->mb_stride]))
184  qp_dt= qp_tt;
185  else
186  qp_dt = s->current_picture.qscale_table[xy - 1 - s->mb_stride];
187 
188  if(qp_dt){
189  const int chroma_qp= s->chroma_qscale_table[qp_dt];
190  s->h263dsp.h263_h_loop_filter(dest_y - 8 * linesize, linesize, qp_dt);
191  s->h263dsp.h263_h_loop_filter(dest_cb - 8 * uvlinesize, uvlinesize, chroma_qp);
192  s->h263dsp.h263_h_loop_filter(dest_cr - 8 * uvlinesize, uvlinesize, chroma_qp);
193  }
194  }
195  }
196 
197  if(qp_c){
198  s->h263dsp.h263_h_loop_filter(dest_y + 8, linesize, qp_c);
199  if(s->mb_y + 1 == s->mb_height)
200  s->h263dsp.h263_h_loop_filter(dest_y + 8 * linesize + 8, linesize, qp_c);
201  }
202 
203  if(s->mb_x){
204  int qp_lc;
205  if (qp_c || IS_SKIP(s->current_picture.mb_type[xy - 1]))
206  qp_lc= qp_c;
207  else
208  qp_lc = s->current_picture.qscale_table[xy - 1];
209 
210  if(qp_lc){
211  s->h263dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
212  if(s->mb_y + 1 == s->mb_height){
213  const int chroma_qp= s->chroma_qscale_table[qp_lc];
214  s->h263dsp.h263_h_loop_filter(dest_y + 8 * linesize, linesize, qp_lc);
215  s->h263dsp.h263_h_loop_filter(dest_cb, uvlinesize, chroma_qp);
216  s->h263dsp.h263_h_loop_filter(dest_cr, uvlinesize, chroma_qp);
217  }
218  }
219  }
220 }
221 
222 void ff_h263_pred_acdc(MpegEncContext * s, int16_t *block, int n)
223 {
224  int x, y, wrap, a, c, pred_dc, scale, i;
225  int16_t *dc_val, *ac_val, *ac_val1;
226 
227  /* find prediction */
228  if (n < 4) {
229  x = 2 * s->mb_x + (n & 1);
230  y = 2 * s->mb_y + (n>> 1);
231  wrap = s->b8_stride;
232  dc_val = s->dc_val[0];
233  ac_val = s->ac_val[0][0];
234  scale = s->y_dc_scale;
235  } else {
236  x = s->mb_x;
237  y = s->mb_y;
238  wrap = s->mb_stride;
239  dc_val = s->dc_val[n - 4 + 1];
240  ac_val = s->ac_val[n - 4 + 1][0];
241  scale = s->c_dc_scale;
242  }
243 
244  ac_val += ((y) * wrap + (x)) * 16;
245  ac_val1 = ac_val;
246 
247  /* B C
248  * A X
249  */
250  a = dc_val[(x - 1) + (y) * wrap];
251  c = dc_val[(x) + (y - 1) * wrap];
252 
253  /* No prediction outside GOB boundary */
254  if(s->first_slice_line && n!=3){
255  if(n!=2) c= 1024;
256  if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
257  }
258 
259  if (s->ac_pred) {
260  pred_dc = 1024;
261  if (s->h263_aic_dir) {
262  /* left prediction */
263  if (a != 1024) {
264  ac_val -= 16;
265  for(i=1;i<8;i++) {
266  block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
267  }
268  pred_dc = a;
269  }
270  } else {
271  /* top prediction */
272  if (c != 1024) {
273  ac_val -= 16 * wrap;
274  for(i=1;i<8;i++) {
275  block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
276  }
277  pred_dc = c;
278  }
279  }
280  } else {
281  /* just DC prediction */
282  if (a != 1024 && c != 1024)
283  pred_dc = (a + c) >> 1;
284  else if (a != 1024)
285  pred_dc = a;
286  else
287  pred_dc = c;
288  }
289 
290  /* we assume pred is positive */
291  block[0]=block[0]*scale + pred_dc;
292 
293  if (block[0] < 0)
294  block[0] = 0;
295  else
296  block[0] |= 1;
297 
298  /* Update AC/DC tables */
299  dc_val[(x) + (y) * wrap] = block[0];
300 
301  /* left copy */
302  for(i=1;i<8;i++)
303  ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
304  /* top copy */
305  for(i=1;i<8;i++)
306  ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
307 }
308 
309 int16_t *ff_h263_pred_motion(MpegEncContext * s, int block, int dir,
310  int *px, int *py)
311 {
312  int wrap;
313  int16_t *A, *B, *C, (*mot_val)[2];
314  static const int off[4]= {2, 1, 1, -1};
315 
316  wrap = s->b8_stride;
317  mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
318 
319  A = mot_val[ - 1];
320  /* special case for first (slice) line */
321  if (s->first_slice_line && block<3) {
322  // we can't just change some MVs to simulate that as we need them for the B-frames (and ME)
323  // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
324  if(block==0){ //most common case
325  if(s->mb_x == s->resync_mb_x){ //rare
326  *px= *py = 0;
327  }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
328  C = mot_val[off[block] - wrap];
329  if(s->mb_x==0){
330  *px = C[0];
331  *py = C[1];
332  }else{
333  *px = mid_pred(A[0], 0, C[0]);
334  *py = mid_pred(A[1], 0, C[1]);
335  }
336  }else{
337  *px = A[0];
338  *py = A[1];
339  }
340  }else if(block==1){
341  if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
342  C = mot_val[off[block] - wrap];
343  *px = mid_pred(A[0], 0, C[0]);
344  *py = mid_pred(A[1], 0, C[1]);
345  }else{
346  *px = A[0];
347  *py = A[1];
348  }
349  }else{ /* block==2*/
350  B = mot_val[ - wrap];
351  C = mot_val[off[block] - wrap];
352  if(s->mb_x == s->resync_mb_x) //rare
353  A[0]=A[1]=0;
354 
355  *px = mid_pred(A[0], B[0], C[0]);
356  *py = mid_pred(A[1], B[1], C[1]);
357  }
358  } else {
359  B = mot_val[ - wrap];
360  C = mot_val[off[block] - wrap];
361  *px = mid_pred(A[0], B[0], C[0]);
362  *py = mid_pred(A[1], B[1], C[1]);
363  }
364  return *mot_val;
365 }
IDCTDSPContext idsp
Definition: mpegvideo.h:227
int8_t * ref_index[2]
Definition: mpegpicture.h:62
const char * s
Definition: avisynth_c.h:768
#define C
int16_t(*[3] ac_val)[16]
used for MPEG-4 AC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:191
#define MB_TYPE_INTRA
Definition: mpegutils.h:75
int16_t(*[2][2] p_field_mv_table)[2]
MV table (2MV per MB) interlaced P-frame encoding.
Definition: mpegvideo.h:251
mpegvideo header.
int qscale
QP.
Definition: mpegvideo.h:201
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:309
int encoding
true if we are encoding (vs decoding)
Definition: mpegvideo.h:111
int field_select[2][2]
Definition: mpegvideo.h:277
static int16_t block[64]
Definition: dct.c:113
uint8_t
Definition: vf_geq.c:46
H.263 tables.
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:177
int ff_h263_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr)
Definition: h263.c:94
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:126
#define A(x)
Definition: vp56_arith.h:28
int16_t * dc_val[3]
used for MPEG-4 DC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:184
H263DSPContext h263dsp
Definition: mpegvideo.h:234
uint8_t * mbskip_table
Definition: mpegpicture.h:59
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:192
#define wrap(func)
Definition: neontest.h:65
#define IS_SKIP(a)
Definition: mpegutils.h:83
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:356
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:135
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
static void FUNC() pred_dc(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int log2_size, int c_idx)
int n
Definition: avisynth_c.h:684
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:293
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
int first_slice_line
used in MPEG-4 too to handle resync markers
Definition: mpegvideo.h:433
Libavcodec external API header.
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:42
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:131
#define MB_TYPE_16x16
Definition: avcodec.h:1256
#define mid_pred
Definition: mathops.h:96
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:132
int h263_pred
use MPEG-4/H.263 ac/dc predictions
Definition: mpegvideo.h:102
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:276
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:128
MpegEncContext.
Definition: mpegvideo.h:78
int8_t * qscale_table
Definition: mpegpicture.h:50
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:127
void ff_h263_pred_acdc(MpegEncContext *s, int16_t *block, int n)
Definition: h263.c:222
void(* h263_v_loop_filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.h:28
uint8_t * dest[3]
Definition: mpegvideo.h:295
#define MB_TYPE_8x8
Definition: avcodec.h:1259
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (H.263)
Definition: mpegvideo.h:187
static AVCodec * c
void(* h263_h_loop_filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.h:27
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:267
int h263_aic_dir
AIC direction: 0 = left, 1 = top.
Definition: mpegvideo.h:376
#define MB_TYPE_L0
Definition: avcodec.h:1269