2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard
5 * Copyright (c) 2001 Juan J. Sierralta P
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
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.
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.
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
35 #include "mpegvideo.h"
41 #include "mpeg4video.h"
46 uint8_t ff_h263_static_rl_table_store
[2][2][2*MAX_RUN
+ MAX_LEVEL
+ 3];
49 void ff_h263_update_motion_val(MpegEncContext
* s
){
50 const int mb_xy
= s
->mb_y
* s
->mb_stride
+ s
->mb_x
;
51 //FIXME a lot of that is only needed for !low_delay
52 const int wrap
= s
->b8_stride
;
53 const int xy
= s
->block_index
[0];
55 s
->current_picture
.mbskip_table
[mb_xy
]= s
->mb_skipped
;
57 if(s
->mv_type
!= MV_TYPE_8X8
){
58 int motion_x
, motion_y
;
62 } else if (s
->mv_type
== MV_TYPE_16X16
) {
63 motion_x
= s
->mv
[0][0][0];
64 motion_y
= s
->mv
[0][0][1];
65 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
67 motion_x
= s
->mv
[0][0][0] + s
->mv
[0][1][0];
68 motion_y
= s
->mv
[0][0][1] + s
->mv
[0][1][1];
69 motion_x
= (motion_x
>>1) | (motion_x
&1);
71 s
->p_field_mv_table
[i
][0][mb_xy
][0]= s
->mv
[0][i
][0];
72 s
->p_field_mv_table
[i
][0][mb_xy
][1]= s
->mv
[0][i
][1];
74 s
->current_picture
.ref_index
[0][4*mb_xy
]=
75 s
->current_picture
.ref_index
[0][4*mb_xy
+ 1]= s
->field_select
[0][0];
76 s
->current_picture
.ref_index
[0][4*mb_xy
+ 2]=
77 s
->current_picture
.ref_index
[0][4*mb_xy
+ 3]= s
->field_select
[0][1];
80 /* no update if 8X8 because it has been done during parsing */
81 s
->current_picture
.motion_val
[0][xy
][0] = motion_x
;
82 s
->current_picture
.motion_val
[0][xy
][1] = motion_y
;
83 s
->current_picture
.motion_val
[0][xy
+ 1][0] = motion_x
;
84 s
->current_picture
.motion_val
[0][xy
+ 1][1] = motion_y
;
85 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = motion_x
;
86 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = motion_y
;
87 s
->current_picture
.motion_val
[0][xy
+ 1 + wrap
][0] = motion_x
;
88 s
->current_picture
.motion_val
[0][xy
+ 1 + wrap
][1] = motion_y
;
91 if(s
->encoding
){ //FIXME encoding MUST be cleaned up
92 if (s
->mv_type
== MV_TYPE_8X8
)
93 s
->current_picture
.mb_type
[mb_xy
]= MB_TYPE_L0
| MB_TYPE_8x8
;
95 s
->current_picture
.mb_type
[mb_xy
]= MB_TYPE_INTRA
;
97 s
->current_picture
.mb_type
[mb_xy
]= MB_TYPE_L0
| MB_TYPE_16x16
;
101 int h263_pred_dc(MpegEncContext
* s
, int n
, int16_t **dc_val_ptr
)
103 int x
, y
, wrap
, a
, c
, pred_dc
;
106 /* find prediction */
108 x
= 2 * s
->mb_x
+ (n
& 1);
109 y
= 2 * s
->mb_y
+ ((n
& 2) >> 1);
111 dc_val
= s
->dc_val
[0];
116 dc_val
= s
->dc_val
[n
- 4 + 1];
121 a
= dc_val
[(x
- 1) + (y
) * wrap
];
122 c
= dc_val
[(x
) + (y
- 1) * wrap
];
124 /* No prediction outside GOB boundary */
125 if(s
->first_slice_line
&& n
!=3){
127 if(n
!=1 && s
->mb_x
== s
->resync_mb_x
) a
= 1024;
129 /* just DC prediction */
130 if (a
!= 1024 && c
!= 1024)
131 pred_dc
= (a
+ c
) >> 1;
137 /* we assume pred is positive */
138 *dc_val_ptr
= &dc_val
[x
+ y
* wrap
];
142 void ff_h263_loop_filter(MpegEncContext
* s
){
144 const int linesize
= s
->linesize
;
145 const int uvlinesize
= s
->uvlinesize
;
146 const int xy
= s
->mb_y
* s
->mb_stride
+ s
->mb_x
;
147 uint8_t *dest_y
= s
->dest
[0];
148 uint8_t *dest_cb
= s
->dest
[1];
149 uint8_t *dest_cr
= s
->dest
[2];
151 // if(s->pict_type==FF_B_TYPE && !s->readable) return;
157 if(!IS_SKIP(s
->current_picture
.mb_type
[xy
])){
159 s
->dsp
.h263_v_loop_filter(dest_y
+8*linesize
, linesize
, qp_c
);
160 s
->dsp
.h263_v_loop_filter(dest_y
+8*linesize
+8, linesize
, qp_c
);
165 int qp_dt
, qp_tt
, qp_tc
;
167 if(IS_SKIP(s
->current_picture
.mb_type
[xy
-s
->mb_stride
]))
170 qp_tt
= s
->current_picture
.qscale_table
[xy
-s
->mb_stride
];
178 const int chroma_qp
= s
->chroma_qscale_table
[qp_tc
];
179 s
->dsp
.h263_v_loop_filter(dest_y
, linesize
, qp_tc
);
180 s
->dsp
.h263_v_loop_filter(dest_y
+8, linesize
, qp_tc
);
182 s
->dsp
.h263_v_loop_filter(dest_cb
, uvlinesize
, chroma_qp
);
183 s
->dsp
.h263_v_loop_filter(dest_cr
, uvlinesize
, chroma_qp
);
187 s
->dsp
.h263_h_loop_filter(dest_y
-8*linesize
+8 , linesize
, qp_tt
);
190 if(qp_tt
|| IS_SKIP(s
->current_picture
.mb_type
[xy
-1-s
->mb_stride
]))
193 qp_dt
= s
->current_picture
.qscale_table
[xy
-1-s
->mb_stride
];
196 const int chroma_qp
= s
->chroma_qscale_table
[qp_dt
];
197 s
->dsp
.h263_h_loop_filter(dest_y
-8*linesize
, linesize
, qp_dt
);
198 s
->dsp
.h263_h_loop_filter(dest_cb
-8*uvlinesize
, uvlinesize
, chroma_qp
);
199 s
->dsp
.h263_h_loop_filter(dest_cr
-8*uvlinesize
, uvlinesize
, chroma_qp
);
205 s
->dsp
.h263_h_loop_filter(dest_y
+8, linesize
, qp_c
);
206 if(s
->mb_y
+ 1 == s
->mb_height
)
207 s
->dsp
.h263_h_loop_filter(dest_y
+8*linesize
+8, linesize
, qp_c
);
212 if(qp_c
|| IS_SKIP(s
->current_picture
.mb_type
[xy
-1]))
215 qp_lc
= s
->current_picture
.qscale_table
[xy
-1];
218 s
->dsp
.h263_h_loop_filter(dest_y
, linesize
, qp_lc
);
219 if(s
->mb_y
+ 1 == s
->mb_height
){
220 const int chroma_qp
= s
->chroma_qscale_table
[qp_lc
];
221 s
->dsp
.h263_h_loop_filter(dest_y
+8* linesize
, linesize
, qp_lc
);
222 s
->dsp
.h263_h_loop_filter(dest_cb
, uvlinesize
, chroma_qp
);
223 s
->dsp
.h263_h_loop_filter(dest_cr
, uvlinesize
, chroma_qp
);
229 void h263_pred_acdc(MpegEncContext
* s
, DCTELEM
*block
, int n
)
231 int x
, y
, wrap
, a
, c
, pred_dc
, scale
, i
;
232 int16_t *dc_val
, *ac_val
, *ac_val1
;
234 /* find prediction */
236 x
= 2 * s
->mb_x
+ (n
& 1);
237 y
= 2 * s
->mb_y
+ (n
>> 1);
239 dc_val
= s
->dc_val
[0];
240 ac_val
= s
->ac_val
[0][0];
241 scale
= s
->y_dc_scale
;
246 dc_val
= s
->dc_val
[n
- 4 + 1];
247 ac_val
= s
->ac_val
[n
- 4 + 1][0];
248 scale
= s
->c_dc_scale
;
251 ac_val
+= ((y
) * wrap
+ (x
)) * 16;
257 a
= dc_val
[(x
- 1) + (y
) * wrap
];
258 c
= dc_val
[(x
) + (y
- 1) * wrap
];
260 /* No prediction outside GOB boundary */
261 if(s
->first_slice_line
&& n
!=3){
263 if(n
!=1 && s
->mb_x
== s
->resync_mb_x
) a
= 1024;
268 if (s
->h263_aic_dir
) {
269 /* left prediction */
273 block
[s
->dsp
.idct_permutation
[i
<<3]] += ac_val
[i
];
282 block
[s
->dsp
.idct_permutation
[i
]] += ac_val
[i
+ 8];
288 /* just DC prediction */
289 if (a
!= 1024 && c
!= 1024)
290 pred_dc
= (a
+ c
) >> 1;
297 /* we assume pred is positive */
298 block
[0]=block
[0]*scale
+ pred_dc
;
305 /* Update AC/DC tables */
306 dc_val
[(x
) + (y
) * wrap
] = block
[0];
310 ac_val1
[i
] = block
[s
->dsp
.idct_permutation
[i
<<3]];
313 ac_val1
[8 + i
] = block
[s
->dsp
.idct_permutation
[i
]];
316 int16_t *h263_pred_motion(MpegEncContext
* s
, int block
, int dir
,
320 int16_t *A
, *B
, *C
, (*mot_val
)[2];
321 static const int off
[4]= {2, 1, 1, -1};
324 mot_val
= s
->current_picture
.motion_val
[dir
] + s
->block_index
[block
];
327 /* special case for first (slice) line */
328 if (s
->first_slice_line
&& block
<3) {
329 // we can't just change some MVs to simulate that as we need them for the B frames (and ME)
330 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
331 if(block
==0){ //most common case
332 if(s
->mb_x
== s
->resync_mb_x
){ //rare
334 }else if(s
->mb_x
+ 1 == s
->resync_mb_x
&& s
->h263_pred
){ //rare
335 C
= mot_val
[off
[block
] - wrap
];
340 *px
= mid_pred(A
[0], 0, C
[0]);
341 *py
= mid_pred(A
[1], 0, C
[1]);
348 if(s
->mb_x
+ 1 == s
->resync_mb_x
&& s
->h263_pred
){ //rare
349 C
= mot_val
[off
[block
] - wrap
];
350 *px
= mid_pred(A
[0], 0, C
[0]);
351 *py
= mid_pred(A
[1], 0, C
[1]);
357 B
= mot_val
[ - wrap
];
358 C
= mot_val
[off
[block
] - wrap
];
359 if(s
->mb_x
== s
->resync_mb_x
) //rare
362 *px
= mid_pred(A
[0], B
[0], C
[0]);
363 *py
= mid_pred(A
[1], B
[1], C
[1]);
366 B
= mot_val
[ - wrap
];
367 C
= mot_val
[off
[block
] - wrap
];
368 *px
= mid_pred(A
[0], B
[0], C
[0]);
369 *py
= mid_pred(A
[1], B
[1], C
[1]);
376 * Get the GOB height based on picture height.
378 int ff_h263_get_gob_height(MpegEncContext
*s
){
379 if (s
->height
<= 400)
381 else if (s
->height
<= 800)