mpeg4 header encoding bugfix
[libav.git] / libavcodec / h263.c
CommitLineData
de6d9b64
FB
1/*
2 * H263/MPEG4 backend for ffmpeg encoder and decoder
ff4ec49e 3 * Copyright (c) 2000,2001 Fabrice Bellard.
6dbd39fe 4 * H263+ support.
de6d9b64
FB
5 * Copyright (c) 2001 Juan J. Sierralta P.
6 *
ff4ec49e
FB
7 * This library 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 of the License, or (at your option) any later version.
de6d9b64 11 *
ff4ec49e 12 * This library is distributed in the hope that it will be useful,
de6d9b64 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ff4ec49e
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
de6d9b64 16 *
ff4ec49e
FB
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
45870f57 20 *
66370d3f
MN
21 * ac prediction encoding, b-frame support, error resilience, optimizations,
22 * qpel decoding, gmc decoding, interlaced decoding,
23 * by Michael Niedermayer <michaelni@gmx.at>
de6d9b64 24 */
1e209222
J
25
26//#define DEBUG
de6d9b64
FB
27#include "common.h"
28#include "dsputil.h"
29#include "avcodec.h"
30#include "mpegvideo.h"
31#include "h263data.h"
32#include "mpeg4data.h"
33
c5d309f2
MN
34//#undef NDEBUG
35//#include <assert.h>
36
c5d309f2 37#if 1
c60a6560 38#define PRINT_MB_TYPE(a) {}
c5d309f2
MN
39#else
40#define PRINT_MB_TYPE(a) printf(a)
41#endif
32cd20de 42
edcf9890
MN
43#define INTRA_MCBPC_VLC_BITS 6
44#define INTER_MCBPC_VLC_BITS 6
45#define CBPY_VLC_BITS 6
46#define MV_VLC_BITS 9
47#define DC_VLC_BITS 9
48#define SPRITE_TRAJ_VLC_BITS 6
49#define MB_TYPE_B_VLC_BITS 4
50#define TEX_VLC_BITS 9
51
bbed9259 52#ifdef CONFIG_ENCODERS
de6d9b64
FB
53static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
54 int n);
9dbcbd92 55static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
6dbd39fe 56static void h263p_encode_umotion(MpegEncContext * s, int val);
3db48188 57static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
92073d01
MN
58 int n, int dc, UINT8 *scan_table,
59 PutBitContext *dc_pb, PutBitContext *ac_pb);
bbed9259
MN
60#endif
61
6f91bcd1 62static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
6dbd39fe 63static int h263p_decode_umotion(MpegEncContext * s, int pred);
de6d9b64
FB
64static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
65 int n, int coded);
92073d01
MN
66static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
67static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
3e6a20a0 68 int n, int coded, int intra);
ef5b1b5a 69static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
d6231b9e
MN
70static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
71 int dir);
49092244 72static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
4d2858de
MN
73static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
74
d6231b9e 75extern UINT32 inverse[256];
de6d9b64 76
bbed9259
MN
77static UINT16 uni_DCtab_lum [512][2];
78static UINT16 uni_DCtab_chrom[512][2];
79
80#ifdef CONFIG_ENCODERS
81static UINT16 (*mv_penalty)[MAX_MV*2+1]= NULL;
45870f57 82static UINT8 fcode_tab[MAX_MV*2+1];
9d2a0355 83static UINT8 umv_fcode_tab[MAX_MV*2+1];
45870f57 84
477ab036
MN
85static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
86static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
87static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
88static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
89//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
3db48188 90//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
477ab036 91#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
3db48188
MN
92
93/* mpeg4
94inter
95max level: 24/6
96max run: 53/63
97
98intra
99max level: 53/16
100max run: 29/41
101*/
bbed9259
MN
102#endif
103
2a164b25 104
de6d9b64
FB
105int h263_get_picture_format(int width, int height)
106{
107 int format;
108
109 if (width == 128 && height == 96)
1e209222 110 format = 1;
de6d9b64 111 else if (width == 176 && height == 144)
1e209222 112 format = 2;
de6d9b64 113 else if (width == 352 && height == 288)
1e209222 114 format = 3;
de6d9b64 115 else if (width == 704 && height == 576)
1e209222 116 format = 4;
de6d9b64 117 else if (width == 1408 && height == 1152)
1e209222 118 format = 5;
de6d9b64
FB
119 else
120 format = 7;
121 return format;
122}
123
58b0b0dd
MN
124static void float_aspect_to_info(MpegEncContext * s, float aspect){
125 int i;
126
127 aspect*= s->height/(double)s->width;
128//printf("%f\n", aspect);
5d3cea3a 129
58b0b0dd
MN
130 if(aspect==0) aspect= 1.0;
131
5d3cea3a 132 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
58b0b0dd
MN
133
134//printf("%d %d\n", s->aspected_width, s->aspected_height);
135 for(i=1; i<6; i++){
136 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
137 s->aspect_ratio_info=i;
138 return;
139 }
140 }
5d3cea3a 141
58b0b0dd 142 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
5d3cea3a
MN
143}
144
de6d9b64
FB
145void h263_encode_picture_header(MpegEncContext * s, int picture_number)
146{
6dbd39fe 147 int format;
de6d9b64
FB
148
149 align_put_bits(&s->pb);
81401c1f
J
150
151 /* Update the pointer to last GOB */
17592475 152 s->ptr_lastgob = pbBufPtr(&s->pb);
81401c1f
J
153 s->gob_number = 0;
154
155 put_bits(&s->pb, 22, 0x20); /* PSC */
bb6f51ae 156 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
de6d9b64
FB
157 s->frame_rate) & 0xff);
158
159 put_bits(&s->pb, 1, 1); /* marker */
160 put_bits(&s->pb, 1, 0); /* h263 id */
161 put_bits(&s->pb, 1, 0); /* split screen off */
162 put_bits(&s->pb, 1, 0); /* camera off */
163 put_bits(&s->pb, 1, 0); /* freeze picture release off */
6dbd39fe
J
164
165 format = h263_get_picture_format(s->width, s->height);
de6d9b64
FB
166 if (!s->h263_plus) {
167 /* H.263v1 */
de6d9b64
FB
168 put_bits(&s->pb, 3, format);
169 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
170 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
171 of H.263v1 UMV implies to check the predicted MV after
172 calculation of the current MB to see if we're on the limits */
173 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
174 put_bits(&s->pb, 1, 0); /* SAC: off */
175 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
176 put_bits(&s->pb, 1, 0); /* not PB frame */
177 put_bits(&s->pb, 5, s->qscale);
178 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
179 } else {
180 /* H.263v2 */
181 /* H.263 Plus PTYPE */
182 put_bits(&s->pb, 3, 7);
183 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
6dbd39fe
J
184 if (format == 7)
185 put_bits(&s->pb,3,6); /* Custom Source Format */
186 else
187 put_bits(&s->pb, 3, format);
188
de6d9b64 189 put_bits(&s->pb,1,0); /* Custom PCF: off */
544286b3
J
190 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
191 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
de6d9b64
FB
192 put_bits(&s->pb,1,0); /* SAC: off */
193 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
ef5b1b5a 194 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
de6d9b64
FB
195 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
196 put_bits(&s->pb,1,0); /* Slice Structured: off */
197 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
198 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
199 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
200 put_bits(&s->pb,1,0); /* Modified Quantization: off */
201 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
202 put_bits(&s->pb,3,0); /* Reserved */
203
204 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
205
206 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
207 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
ef5b1b5a 208 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
de6d9b64
FB
209 put_bits(&s->pb,2,0); /* Reserved */
210 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
211
212 /* This should be here if PLUSPTYPE */
213 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
214
6dbd39fe
J
215 if (format == 7) {
216 /* Custom Picture Format (CPFMT) */
58b0b0dd 217 float_aspect_to_info(s, s->avctx->aspect_ratio);
5d3cea3a
MN
218
219 put_bits(&s->pb,4,s->aspect_ratio_info);
6dbd39fe
J
220 put_bits(&s->pb,9,(s->width >> 2) - 1);
221 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
222 put_bits(&s->pb,9,(s->height >> 2));
050fe8ba
AB
223 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
224 {
225 put_bits(&s->pb, 8, s->aspected_width);
226 put_bits(&s->pb, 8, s->aspected_height);
227 }
6dbd39fe
J
228 }
229
de6d9b64 230 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
544286b3 231 if (s->umvplus)
de6d9b64
FB
232 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
233 put_bits(&s->pb, 5, s->qscale);
234 }
235
236 put_bits(&s->pb, 1, 0); /* no PEI */
8f8402e4
MN
237
238 if(s->h263_aic){
239 s->y_dc_scale_table=
240 s->c_dc_scale_table= h263_aic_dc_scale_table;
241 }else{
242 s->y_dc_scale_table=
243 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
244 }
de6d9b64
FB
245}
246
945eeee1
MN
247/**
248 * Encodes a group of blocks header.
249 */
644d98a4
J
250int h263_encode_gob_header(MpegEncContext * s, int mb_line)
251{
644d98a4 252 align_put_bits(&s->pb);
81401c1f
J
253 flush_put_bits(&s->pb);
254 /* Call the RTP callback to send the last GOB */
255 if (s->rtp_callback) {
945eeee1 256 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
81401c1f
J
257 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
258 }
644d98a4 259 put_bits(&s->pb, 17, 1); /* GBSC */
81401c1f 260 s->gob_number = mb_line / s->gob_index;
644d98a4 261 put_bits(&s->pb, 5, s->gob_number); /* GN */
81401c1f 262 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
644d98a4 263 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
81401c1f 264 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
945eeee1 265 return 0;
644d98a4 266}
d6231b9e
MN
267
268static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
269{
270 int score0=0, score1=0;
271 int i, n;
1e491e29 272 int8_t * const qscale_table= s->current_picture.qscale_table;
d6231b9e
MN
273
274 for(n=0; n<6; n++){
d6231b9e
MN
275 INT16 *ac_val, *ac_val1;
276
4278e7a6 277 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
d6231b9e
MN
278 ac_val1= ac_val;
279 if(dir[n]){
99609036
MN
280 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
281 /* top prediction */
4278e7a6 282 ac_val-= s->block_wrap[n]*16;
1e491e29 283 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
99609036
MN
284 /* same qscale */
285 for(i=1; i<8; i++){
2ad1516a 286 const int level= block[n][s->idct_permutation[i ]];
99609036
MN
287 score0+= ABS(level);
288 score1+= ABS(level - ac_val[i+8]);
2ad1516a 289 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
99609036
MN
290 ac_val1[i+8]= level;
291 }
292 }else{
293 /* different qscale, we must rescale */
294 for(i=1; i<8; i++){
2ad1516a 295 const int level= block[n][s->idct_permutation[i ]];
99609036 296 score0+= ABS(level);
1e491e29 297 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
2ad1516a 298 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
99609036
MN
299 ac_val1[i+8]= level;
300 }
d6231b9e
MN
301 }
302 }else{
99609036
MN
303 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
304 /* left prediction */
d6231b9e 305 ac_val-= 16;
1e491e29 306 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
99609036
MN
307 /* same qscale */
308 for(i=1; i<8; i++){
2ad1516a 309 const int level= block[n][s->idct_permutation[i<<3]];
99609036
MN
310 score0+= ABS(level);
311 score1+= ABS(level - ac_val[i]);
312 ac_val1[i ]= level;
2ad1516a 313 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
99609036
MN
314 }
315 }else{
316 /* different qscale, we must rescale */
317 for(i=1; i<8; i++){
2ad1516a 318 const int level= block[n][s->idct_permutation[i<<3]];
99609036 319 score0+= ABS(level);
1e491e29 320 score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
99609036 321 ac_val1[i ]= level;
2ad1516a 322 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
99609036 323 }
d6231b9e
MN
324 }
325 }
326 }
327
328 return score0 > score1 ? 1 : 0;
329}
330
4d2858de
MN
331/**
332 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
333 */
9e4c6948 334void ff_clean_h263_qscales(MpegEncContext *s){
c5d309f2 335 int i;
1e491e29 336 int8_t * const qscale_table= s->current_picture.qscale_table;
c5d309f2
MN
337
338 for(i=1; i<s->mb_num; i++){
1e491e29
MN
339 if(qscale_table[i] - qscale_table[i-1] >2)
340 qscale_table[i]= qscale_table[i-1]+2;
c5d309f2
MN
341 }
342 for(i=s->mb_num-2; i>=0; i--){
1e491e29
MN
343 if(qscale_table[i] - qscale_table[i+1] >2)
344 qscale_table[i]= qscale_table[i+1]+2;
c5d309f2 345 }
9e4c6948
MN
346}
347
4d2858de
MN
348/**
349 * modify mb_type & qscale so that encoding is acually possible in mpeg4
350 */
9e4c6948
MN
351void ff_clean_mpeg4_qscales(MpegEncContext *s){
352 int i;
1e491e29
MN
353 int8_t * const qscale_table= s->current_picture.qscale_table;
354
9e4c6948 355 ff_clean_h263_qscales(s);
c5d309f2
MN
356
357 for(i=1; i<s->mb_num; i++){
1e491e29 358 if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
c5d309f2
MN
359 s->mb_type[i]&= ~MB_TYPE_INTER4V;
360 s->mb_type[i]|= MB_TYPE_INTER;
361 }
362 }
363
364 if(s->pict_type== B_TYPE){
365 int odd=0;
366 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
367 for the actual adaptive quantization */
368
369 for(i=0; i<s->mb_num; i++){
1e491e29 370 odd += qscale_table[i]&1;
c5d309f2
MN
371 }
372
373 if(2*odd > s->mb_num) odd=1;
374 else odd=0;
375
376 for(i=0; i<s->mb_num; i++){
1e491e29
MN
377 if((qscale_table[i]&1) != odd)
378 qscale_table[i]++;
379 if(qscale_table[i] > 31)
380 qscale_table[i]= 31;
c5d309f2
MN
381 }
382
383 for(i=1; i<s->mb_num; i++){
1e491e29 384 if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
c5d309f2
MN
385 s->mb_type[i]&= ~MB_TYPE_DIRECT;
386 s->mb_type[i]|= MB_TYPE_BIDIR;
387 }
388 }
389 }
390}
391
1457ab52
MN
392void ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
393 const int mb_index= s->mb_x + s->mb_y*s->mb_width;
394 int xy= s->block_index[0];
395 uint16_t time_pp= s->pp_time;
396 uint16_t time_pb= s->pb_time;
397 int i;
398
399 //FIXME avoid divides
400 switch(s->co_located_type_table[mb_index]){
401 case 0:
402 s->mv_type= MV_TYPE_16X16;
403 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
404 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
405 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
406 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
407 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
408 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
409 break;
410 case CO_LOCATED_TYPE_4MV:
411 s->mv_type = MV_TYPE_8X8;
412 for(i=0; i<4; i++){
413 xy= s->block_index[i];
414 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
415 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
416 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
417 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
418 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
419 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
420 }
421 break;
422 case CO_LOCATED_TYPE_FIELDMV:
423 s->mv_type = MV_TYPE_FIELD;
424 for(i=0; i<2; i++){
425 if(s->top_field_first){
426 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
427 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
428 }else{
429 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
430 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
431 }
432 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
433 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
434 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
435 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
436 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
437 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
438 }
439 break;
440 }
441}
442
bbed9259 443#ifdef CONFIG_ENCODERS
d6231b9e
MN
444void mpeg4_encode_mb(MpegEncContext * s,
445 DCTELEM block[6][64],
446 int motion_x, int motion_y)
447{
9dbcbd92 448 int cbpc, cbpy, i, pred_x, pred_y;
098eefe1 449 int bits;
92073d01
MN
450 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
451 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
452 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
453 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
c5d309f2 454 const int dquant_code[5]= {1,0,9,2,3};
644d98a4 455
d6231b9e
MN
456 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
457 if (!s->mb_intra) {
458 /* compute cbp */
9dbcbd92 459 int cbp = 0;
d6231b9e 460 for (i = 0; i < 6; i++) {
9dbcbd92
MN
461 if (s->block_last_index[i] >= 0)
462 cbp |= 1 << (5 - i);
d6231b9e 463 }
9dbcbd92
MN
464
465 if(s->pict_type==B_TYPE){
466 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
467 int mb_type= mb_type_table[s->mv_dir];
468
469 if(s->mb_x==0){
470 s->last_mv[0][0][0]=
471 s->last_mv[0][0][1]=
472 s->last_mv[1][0][0]=
473 s->last_mv[1][0][1]= 0;
474 }
c5d309f2
MN
475
476 assert(s->dquant>=-2 && s->dquant<=2);
477 assert((s->dquant&1)==0);
478 assert(mb_type>=0);
9dbcbd92
MN
479
480 /* nothing to do if this MB was skiped in the next P Frame */
1e491e29 481 if(s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
9dbcbd92
MN
482 s->skip_count++;
483 s->mv[0][0][0]=
484 s->mv[0][0][1]=
485 s->mv[1][0][0]=
486 s->mv[1][0][1]= 0;
91029be7 487 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
c5d309f2 488 s->qscale -= s->dquant;
1e491e29
MN
489// s->mb_skiped=1;
490
9dbcbd92
MN
491 return;
492 }
1457ab52 493
9dbcbd92
MN
494 if ((cbp | motion_x | motion_y | mb_type) ==0) {
495 /* direct MB with MV={0,0} */
c5d309f2
MN
496 assert(s->dquant==0);
497
9dbcbd92 498 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
92073d01
MN
499
500 if(interleaved_stats){
501 s->misc_bits++;
502 s->last_bits++;
503 }
9dbcbd92
MN
504 s->skip_count++;
505 return;
506 }
1e491e29 507
9dbcbd92
MN
508 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
509 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
510 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
511 if(cbp) put_bits(&s->pb, 6, cbp);
512
c5d309f2
MN
513 if(cbp && mb_type){
514 if(s->dquant)
515 put_bits(&s->pb, 2, (s->dquant>>2)+3);
516 else
517 put_bits(&s->pb, 1, 0);
518 }else
519 s->qscale -= s->dquant;
fcb48651
MN
520
521 if(!s->progressive_sequence){
522 if(cbp)
523 put_bits(&s->pb, 1, s->interlaced_dct);
524 if(mb_type) // not diect mode
525 put_bits(&s->pb, 1, 0); // no interlaced ME yet
526 }
9dbcbd92 527
92073d01
MN
528 if(interleaved_stats){
529 bits= get_bit_count(&s->pb);
530 s->misc_bits+= bits - s->last_bits;
531 s->last_bits=bits;
532 }
cf8039b2 533
9dbcbd92
MN
534 switch(mb_type)
535 {
536 case 0: /* direct */
537 h263_encode_motion(s, motion_x, 1);
538 h263_encode_motion(s, motion_y, 1);
66370d3f
MN
539 s->b_count++;
540 s->f_count++;
9dbcbd92
MN
541 break;
542 case 1: /* bidir */
543 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
544 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
545 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
546 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
547 s->last_mv[0][0][0]= s->mv[0][0][0];
548 s->last_mv[0][0][1]= s->mv[0][0][1];
549 s->last_mv[1][0][0]= s->mv[1][0][0];
550 s->last_mv[1][0][1]= s->mv[1][0][1];
66370d3f
MN
551 s->b_count++;
552 s->f_count++;
9dbcbd92
MN
553 break;
554 case 2: /* backward */
555 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
556 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
557 s->last_mv[1][0][0]= motion_x;
558 s->last_mv[1][0][1]= motion_y;
66370d3f 559 s->b_count++;
9dbcbd92
MN
560 break;
561 case 3: /* forward */
562 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
563 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
564 s->last_mv[0][0][0]= motion_x;
565 s->last_mv[0][0][1]= motion_y;
66370d3f 566 s->f_count++;
9dbcbd92 567 break;
91029be7
MN
568 default:
569 printf("unknown mb type\n");
9dbcbd92
MN
570 return;
571 }
92073d01
MN
572
573 if(interleaved_stats){
574 bits= get_bit_count(&s->pb);
575 s->mv_bits+= bits - s->last_bits;
576 s->last_bits=bits;
577 }
d6231b9e 578
9dbcbd92
MN
579 /* encode each block */
580 for (i = 0; i < 6; i++) {
2ad1516a 581 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
92073d01
MN
582 }
583
584 if(interleaved_stats){
585 bits= get_bit_count(&s->pb);
586 s->p_tex_bits+= bits - s->last_bits;
587 s->last_bits=bits;
9dbcbd92 588 }
9dbcbd92 589 }else{ /* s->pict_type==B_TYPE */
c5d309f2 590 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
ee6f7861
MN
591 /* check if the B frames can skip it too, as we must skip it if we skip here
592 why didnt they just compress the skip-mb bits instead of reusing them ?! */
593 if(s->max_b_frames>0){
594 int i;
e71a4f74
MN
595 int x,y, offset;
596 uint8_t *p_pic;
597
598 x= s->mb_x*16;
599 y= s->mb_y*16;
600 if(x+16 > s->width) x= s->width-16;
601 if(y+16 > s->height) y= s->height-16;
602
603 offset= x + y*s->linesize;
1e491e29 604 p_pic= s->new_picture.data[0] + offset;
e71a4f74 605
ee6f7861
MN
606 s->mb_skiped=1;
607 for(i=0; i<s->max_b_frames; i++){
d697b89b
MN
608 uint8_t *b_pic;
609 int diff;
1e491e29 610 Picture *pic= s->reordered_input_picture[i+1];
d697b89b 611
1e491e29 612 if(pic==NULL || pic->pict_type!=B_TYPE) break;
d697b89b 613
1e491e29 614 b_pic= pic->data[0] + offset + 16; //FIXME +16
eb4b3dd3 615 diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
e71a4f74 616 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
ee6f7861
MN
617 s->mb_skiped=0;
618 break;
619 }
620 }
621 }else
622 s->mb_skiped=1;
623
624 if(s->mb_skiped==1){
625 /* skip macroblock */
626 put_bits(&s->pb, 1, 1);
92073d01
MN
627
628 if(interleaved_stats){
629 s->misc_bits++;
630 s->last_bits++;
631 }
ee6f7861
MN
632 s->skip_count++;
633 return;
634 }
9dbcbd92 635 }
e71a4f74 636
9dbcbd92
MN
637 put_bits(&s->pb, 1, 0); /* mb coded */
638 if(s->mv_type==MV_TYPE_16X16){
639 cbpc = cbp & 3;
c5d309f2 640 if(s->dquant) cbpc+= 8;
9dbcbd92
MN
641 put_bits(&s->pb,
642 inter_MCBPC_bits[cbpc],
643 inter_MCBPC_code[cbpc]);
c5d309f2 644
9dbcbd92
MN
645 cbpy = cbp >> 2;
646 cbpy ^= 0xf;
92073d01 647 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
c5d309f2
MN
648 if(s->dquant)
649 put_bits(pb2, 2, dquant_code[s->dquant+2]);
fcb48651
MN
650
651 if(!s->progressive_sequence){
652 if(cbp)
653 put_bits(pb2, 1, s->interlaced_dct);
654 put_bits(pb2, 1, 0); // no interlaced ME yet
655 }
9dbcbd92 656
92073d01
MN
657 if(interleaved_stats){
658 bits= get_bit_count(&s->pb);
659 s->misc_bits+= bits - s->last_bits;
660 s->last_bits=bits;
661 }
d6231b9e 662
9dbcbd92
MN
663 /* motion vectors: 16x16 mode */
664 h263_pred_motion(s, 0, &pred_x, &pred_y);
665
666 h263_encode_motion(s, motion_x - pred_x, s->f_code);
667 h263_encode_motion(s, motion_y - pred_y, s->f_code);
668 }else{
669 cbpc = (cbp & 3)+16;
670 put_bits(&s->pb,
671 inter_MCBPC_bits[cbpc],
672 inter_MCBPC_code[cbpc]);
673 cbpy = cbp >> 2;
674 cbpy ^= 0xf;
92073d01 675 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
9dbcbd92 676
49943a18
MN
677 if(!s->progressive_sequence){
678 if(cbp)
679 put_bits(pb2, 1, s->interlaced_dct);
680 }
681
92073d01
MN
682 if(interleaved_stats){
683 bits= get_bit_count(&s->pb);
684 s->misc_bits+= bits - s->last_bits;
685 s->last_bits=bits;
686 }
9dbcbd92
MN
687
688 for(i=0; i<4; i++){
689 /* motion vectors: 8x8 mode*/
690 h263_pred_motion(s, i, &pred_x, &pred_y);
691
692 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
693 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
694 }
cf8039b2 695 }
92073d01
MN
696
697 if(interleaved_stats){
698 bits= get_bit_count(&s->pb);
699 s->mv_bits+= bits - s->last_bits;
700 s->last_bits=bits;
701 }
098eefe1 702
9dbcbd92
MN
703 /* encode each block */
704 for (i = 0; i < 6; i++) {
2ad1516a 705 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
92073d01
MN
706 }
707
708 if(interleaved_stats){
709 bits= get_bit_count(&s->pb);
710 s->p_tex_bits+= bits - s->last_bits;
711 s->last_bits=bits;
9dbcbd92 712 }
66370d3f 713 s->f_count++;
d6231b9e
MN
714 }
715 } else {
9dbcbd92 716 int cbp;
d6231b9e
MN
717 int dc_diff[6]; //dc values with the dc prediction subtracted
718 int dir[6]; //prediction direction
719 int zigzag_last_index[6];
720 UINT8 *scan_table[6];
721
722 for(i=0; i<6; i++){
723 const int level= block[i][0];
724 UINT16 *dc_ptr;
725
8f8402e4 726 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
d6231b9e
MN
727 if (i < 4) {
728 *dc_ptr = level * s->y_dc_scale;
729 } else {
730 *dc_ptr = level * s->c_dc_scale;
731 }
732 }
733
734 s->ac_pred= decide_ac_pred(s, block, dir);
735
736 if(s->ac_pred){
737 for(i=0; i<6; i++){
738 UINT8 *st;
739 int last_index;
740
741 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
2ad1516a
MN
742 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
743 else st = s->intra_h_scantable.permutated; /* top */
d6231b9e
MN
744
745 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
746 if(block[i][st[last_index]]) break;
747 zigzag_last_index[i]= s->block_last_index[i];
748 s->block_last_index[i]= last_index;
749 scan_table[i]= st;
750 }
751 }else{
752 for(i=0; i<6; i++)
2ad1516a 753 scan_table[i]= s->intra_scantable.permutated;
d6231b9e
MN
754 }
755
756 /* compute cbp */
757 cbp = 0;
758 for (i = 0; i < 6; i++) {
759 if (s->block_last_index[i] >= 1)
760 cbp |= 1 << (5 - i);
761 }
762
763 cbpc = cbp & 3;
764 if (s->pict_type == I_TYPE) {
c5d309f2 765 if(s->dquant) cbpc+=4;
d6231b9e
MN
766 put_bits(&s->pb,
767 intra_MCBPC_bits[cbpc],
768 intra_MCBPC_code[cbpc]);
769 } else {
c5d309f2 770 if(s->dquant) cbpc+=8;
d6231b9e
MN
771 put_bits(&s->pb, 1, 0); /* mb coded */
772 put_bits(&s->pb,
773 inter_MCBPC_bits[cbpc + 4],
774 inter_MCBPC_code[cbpc + 4]);
775 }
92073d01 776 put_bits(pb2, 1, s->ac_pred);
d6231b9e 777 cbpy = cbp >> 2;
92073d01 778 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
c5d309f2
MN
779 if(s->dquant)
780 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
d6231b9e 781
fcb48651
MN
782 if(!s->progressive_sequence){
783 put_bits(dc_pb, 1, s->interlaced_dct);
784 }
785
92073d01
MN
786 if(interleaved_stats){
787 bits= get_bit_count(&s->pb);
788 s->misc_bits+= bits - s->last_bits;
789 s->last_bits=bits;
790 }
098eefe1 791
d6231b9e
MN
792 /* encode each block */
793 for (i = 0; i < 6; i++) {
92073d01 794 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
d6231b9e
MN
795 }
796
92073d01
MN
797 if(interleaved_stats){
798 bits= get_bit_count(&s->pb);
799 s->i_tex_bits+= bits - s->last_bits;
800 s->last_bits=bits;
801 }
098eefe1
MN
802 s->i_count++;
803
d6231b9e
MN
804 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
805 if(s->ac_pred){
806 for(i=0; i<6; i++){
807 int j;
d6231b9e
MN
808 INT16 *ac_val;
809
4278e7a6 810 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
d6231b9e
MN
811
812 if(dir[i]){
813 for(j=1; j<8; j++)
2ad1516a 814 block[i][s->idct_permutation[j ]]= ac_val[j+8];
d6231b9e
MN
815 }else{
816 for(j=1; j<8; j++)
2ad1516a 817 block[i][s->idct_permutation[j<<3]]= ac_val[j ];
d6231b9e
MN
818 }
819 s->block_last_index[i]= zigzag_last_index[i];
820 }
821 }
822 }
823}
824
de6d9b64
FB
825void h263_encode_mb(MpegEncContext * s,
826 DCTELEM block[6][64],
827 int motion_x, int motion_y)
828{
829 int cbpc, cbpy, i, cbp, pred_x, pred_y;
ef5b1b5a
J
830 INT16 pred_dc;
831 INT16 rec_intradc[6];
832 UINT16 *dc_ptr[6];
9e4c6948 833 const int dquant_code[5]= {1,0,9,2,3};
ef5b1b5a
J
834
835 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
9dbcbd92 836 if (!s->mb_intra) {
ef5b1b5a 837 /* compute cbp */
9dbcbd92
MN
838 cbp = 0;
839 for (i = 0; i < 6; i++) {
840 if (s->block_last_index[i] >= 0)
841 cbp |= 1 << (5 - i);
842 }
9e4c6948 843 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
9dbcbd92
MN
844 /* skip macroblock */
845 put_bits(&s->pb, 1, 1);
846 return;
847 }
ef5b1b5a 848 put_bits(&s->pb, 1, 0); /* mb coded */
9dbcbd92 849 cbpc = cbp & 3;
9e4c6948 850 if(s->dquant) cbpc+= 8;
9dbcbd92 851 put_bits(&s->pb,
ef5b1b5a
J
852 inter_MCBPC_bits[cbpc],
853 inter_MCBPC_code[cbpc]);
9dbcbd92
MN
854 cbpy = cbp >> 2;
855 cbpy ^= 0xf;
856 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
9e4c6948
MN
857 if(s->dquant)
858 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
9dbcbd92 859
ef5b1b5a 860 /* motion vectors: 16x16 mode only now */
9dbcbd92 861 h263_pred_motion(s, 0, &pred_x, &pred_y);
6dbd39fe 862
9dbcbd92
MN
863 if (!s->umvplus) {
864 h263_encode_motion(s, motion_x - pred_x, s->f_code);
865 h263_encode_motion(s, motion_y - pred_y, s->f_code);
866 }
867 else {
868 h263p_encode_umotion(s, motion_x - pred_x);
869 h263p_encode_umotion(s, motion_y - pred_y);
870 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
ef5b1b5a 871 /* To prevent Start Code emulation */
9dbcbd92
MN
872 put_bits(&s->pb,1,1);
873 }
ef5b1b5a
J
874 } else {
875 int li = s->h263_aic ? 0 : 1;
876
877 cbp = 0;
878 for(i=0; i<6; i++) {
879 /* Predict DC */
880 if (s->h263_aic && s->mb_intra) {
881 INT16 level = block[i][0];
882
883 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
884 level -= pred_dc;
885 /* Quant */
886 if (level < 0)
887 level = (level + (s->qscale >> 1))/(s->y_dc_scale);
888 else
889 level = (level - (s->qscale >> 1))/(s->y_dc_scale);
890
891 /* AIC can change CBP */
892 if (level == 0 && s->block_last_index[i] == 0)
893 s->block_last_index[i] = -1;
894 else if (level < -127)
895 level = -127;
896 else if (level > 127)
897 level = 127;
898
899 block[i][0] = level;
900 /* Reconstruction */
901 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
902 /* Oddify */
903 rec_intradc[i] |= 1;
904 //if ((rec_intradc[i] % 2) == 0)
905 // rec_intradc[i]++;
906 /* Clipping */
907 if (rec_intradc[i] < 0)
908 rec_intradc[i] = 0;
909 else if (rec_intradc[i] > 2047)
910 rec_intradc[i] = 2047;
911
912 /* Update AC/DC tables */
913 *dc_ptr[i] = rec_intradc[i];
914 }
915 /* compute cbp */
916 if (s->block_last_index[i] >= li)
917 cbp |= 1 << (5 - i);
918 }
de6d9b64 919
ef5b1b5a
J
920 cbpc = cbp & 3;
921 if (s->pict_type == I_TYPE) {
9e4c6948 922 if(s->dquant) cbpc+=4;
ef5b1b5a
J
923 put_bits(&s->pb,
924 intra_MCBPC_bits[cbpc],
925 intra_MCBPC_code[cbpc]);
926 } else {
9e4c6948 927 if(s->dquant) cbpc+=8;
ef5b1b5a
J
928 put_bits(&s->pb, 1, 0); /* mb coded */
929 put_bits(&s->pb,
930 inter_MCBPC_bits[cbpc + 4],
931 inter_MCBPC_code[cbpc + 4]);
932 }
933 if (s->h263_aic) {
934 /* XXX: currently, we do not try to use ac prediction */
935 put_bits(&s->pb, 1, 0); /* no AC prediction */
936 }
937 cbpy = cbp >> 2;
938 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
9e4c6948
MN
939 if(s->dquant)
940 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
de6d9b64
FB
941 }
942
ef5b1b5a
J
943 for(i=0; i<6; i++) {
944 /* encode each block */
ba6802de 945 h263_encode_block(s, block[i], i);
ef5b1b5a
J
946
947 /* Update INTRADC for decoding */
948 if (s->h263_aic && s->mb_intra) {
949 block[i][0] = rec_intradc[i];
950
951 }
952 }
953}
bbed9259 954#endif
ef5b1b5a
J
955
956static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
957{
958 int x, y, wrap, a, c, pred_dc, scale;
959 INT16 *dc_val, *ac_val;
960
961 /* find prediction */
962 if (n < 4) {
963 x = 2 * s->mb_x + 1 + (n & 1);
964 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
965 wrap = s->mb_width * 2 + 2;
966 dc_val = s->dc_val[0];
967 ac_val = s->ac_val[0][0];
968 scale = s->y_dc_scale;
969 } else {
970 x = s->mb_x + 1;
971 y = s->mb_y + 1;
972 wrap = s->mb_width + 2;
973 dc_val = s->dc_val[n - 4 + 1];
974 ac_val = s->ac_val[n - 4 + 1][0];
975 scale = s->c_dc_scale;
de6d9b64 976 }
ef5b1b5a
J
977 /* B C
978 * A X
979 */
980 a = dc_val[(x - 1) + (y) * wrap];
981 c = dc_val[(x) + (y - 1) * wrap];
982
983 /* No prediction outside GOB boundary */
92073d01 984 if (s->first_slice_line && ((n < 2) || (n > 3)))
ef5b1b5a
J
985 c = 1024;
986 pred_dc = 1024;
987 /* just DC prediction */
988 if (a != 1024 && c != 1024)
989 pred_dc = (a + c) >> 1;
990 else if (a != 1024)
991 pred_dc = a;
992 else
993 pred_dc = c;
994
995 /* we assume pred is positive */
996 //pred_dc = (pred_dc + (scale >> 1)) / scale;
997 *dc_val_ptr = &dc_val[x + y * wrap];
998 return pred_dc;
de6d9b64
FB
999}
1000
ef5b1b5a 1001
9e15ad28 1002void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
d140623f 1003{
9e15ad28
J
1004 int x, y, wrap, a, c, pred_dc, scale, i;
1005 INT16 *dc_val, *ac_val, *ac_val1;
d140623f
J
1006
1007 /* find prediction */
1008 if (n < 4) {
1009 x = 2 * s->mb_x + 1 + (n & 1);
1010 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1011 wrap = s->mb_width * 2 + 2;
1012 dc_val = s->dc_val[0];
9e15ad28 1013 ac_val = s->ac_val[0][0];
d140623f
J
1014 scale = s->y_dc_scale;
1015 } else {
1016 x = s->mb_x + 1;
1017 y = s->mb_y + 1;
1018 wrap = s->mb_width + 2;
1019 dc_val = s->dc_val[n - 4 + 1];
9e15ad28 1020 ac_val = s->ac_val[n - 4 + 1][0];
d140623f
J
1021 scale = s->c_dc_scale;
1022 }
9e15ad28
J
1023
1024 ac_val += ((y) * wrap + (x)) * 16;
1025 ac_val1 = ac_val;
1026
d140623f
J
1027 /* B C
1028 * A X
1029 */
1030 a = dc_val[(x - 1) + (y) * wrap];
1031 c = dc_val[(x) + (y - 1) * wrap];
1032
ef5b1b5a 1033 /* No prediction outside GOB boundary */
92073d01 1034 if (s->first_slice_line && ((n < 2) || (n > 3)))
ef5b1b5a 1035 c = 1024;
9e15ad28 1036 pred_dc = 1024;
d140623f
J
1037 if (s->ac_pred) {
1038 if (s->h263_aic_dir) {
1039 /* left prediction */
9e15ad28
J
1040 if (a != 1024) {
1041 ac_val -= 16;
1042 for(i=1;i<8;i++) {
2ad1516a 1043 block[s->idct_permutation[i<<3]] += ac_val[i];
9e15ad28
J
1044 }
1045 pred_dc = a;
d140623f
J
1046 }
1047 } else {
1048 /* top prediction */
9e15ad28
J
1049 if (c != 1024) {
1050 ac_val -= 16 * wrap;
1051 for(i=1;i<8;i++) {
2ad1516a 1052 block[s->idct_permutation[i ]] += ac_val[i + 8];
9e15ad28
J
1053 }
1054 pred_dc = c;
d140623f
J
1055 }
1056 }
9e15ad28
J
1057 } else {
1058 /* just DC prediction */
1059 if (a != 1024 && c != 1024)
1060 pred_dc = (a + c) >> 1;
1061 else if (a != 1024)
1062 pred_dc = a;
1063 else
1064 pred_dc = c;
d140623f 1065 }
9e15ad28
J
1066
1067 /* we assume pred is positive */
1068 block[0]=block[0]*scale + pred_dc;
1069
1070 if (block[0] < 0)
1071 block[0] = 0;
1072 else if (!(block[0] & 1))
1073 block[0]++;
1074
1075 /* Update AC/DC tables */
1076 dc_val[(x) + (y) * wrap] = block[0];
1077
d140623f
J
1078 /* left copy */
1079 for(i=1;i<8;i++)
2ad1516a 1080 ac_val1[i ] = block[s->idct_permutation[i<<3]];
d140623f
J
1081 /* top copy */
1082 for(i=1;i<8;i++)
2ad1516a 1083 ac_val1[8 + i] = block[s->idct_permutation[i ]];
d140623f
J
1084}
1085
de6d9b64
FB
1086INT16 *h263_pred_motion(MpegEncContext * s, int block,
1087 int *px, int *py)
1088{
4278e7a6 1089 int xy, wrap;
de6d9b64 1090 INT16 *A, *B, *C, *mot_val;
49c9325f 1091 static const int off[4]= {2, 1, 1, -1};
de6d9b64 1092
4278e7a6
MN
1093 wrap = s->block_wrap[0];
1094 xy = s->block_index[block];
de6d9b64 1095
af8793ae 1096 mot_val = s->motion_val[xy];
de6d9b64 1097
92073d01
MN
1098 A = s->motion_val[xy - 1];
1099 /* special case for first (slice) line */
4d2858de 1100 if (s->first_slice_line && block<3) {
92073d01
MN
1101 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1102 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1103 if(block==0){ //most common case
1104 if(s->mb_x == s->resync_mb_x){ //rare
1105 *px= *py = 0;
1106 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1107 C = s->motion_val[xy + off[block] - wrap];
1108 if(s->mb_x==0){
1109 *px = C[0];
1110 *py = C[1];
1111 }else{
1112 *px = mid_pred(A[0], 0, C[0]);
1113 *py = mid_pred(A[1], 0, C[1]);
1114 }
1115 }else{
1116 *px = A[0];
1117 *py = A[1];
1118 }
1119 }else if(block==1){
1120 if(s->mb_x + 1 == s->resync_mb_x){ //rare
1121 C = s->motion_val[xy + off[block] - wrap];
1122 *px = mid_pred(A[0], 0, C[0]);
1123 *py = mid_pred(A[1], 0, C[1]);
1124 }else{
1125 *px = A[0];
1126 *py = A[1];
1127 }
1128 }else{ /* block==2*/
1129 B = s->motion_val[xy - wrap];
1130 C = s->motion_val[xy + off[block] - wrap];
1131 if(s->mb_x == s->resync_mb_x) //rare
1132 A[0]=A[1]=0;
1133
1134 *px = mid_pred(A[0], B[0], C[0]);
1135 *py = mid_pred(A[1], B[1], C[1]);
1136 }
de6d9b64 1137 } else {
49c9325f
MN
1138 B = s->motion_val[xy - wrap];
1139 C = s->motion_val[xy + off[block] - wrap];
de6d9b64
FB
1140 *px = mid_pred(A[0], B[0], C[0]);
1141 *py = mid_pred(A[1], B[1], C[1]);
1142 }
1143 return mot_val;
1144}
1145
bbed9259 1146#ifdef CONFIG_ENCODERS
9dbcbd92 1147static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
de6d9b64 1148{
a9c68306 1149 int range, l, bit_size, sign, code, bits;
de6d9b64
FB
1150
1151 if (val == 0) {
1152 /* zero vector */
1153 code = 0;
1154 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1155 } else {
9dbcbd92 1156 bit_size = f_code - 1;
de6d9b64
FB
1157 range = 1 << bit_size;
1158 /* modulo encoding */
1159 l = range * 32;
a9c68306
MN
1160#if 1
1161 val+= l;
1162 val&= 2*l-1;
1163 val-= l;
1164 sign = val>>31;
1165 val= (val^sign)-sign;
1166 sign&=1;
1167#else
de6d9b64 1168 if (val < -l) {
a9c68306 1169 val += 2*l;
de6d9b64 1170 } else if (val >= l) {
a9c68306 1171 val -= 2*l;
de6d9b64 1172 }
a9c68306 1173
c5d309f2 1174 assert(val>=-l && val<l);
de6d9b64
FB
1175
1176 if (val >= 0) {
de6d9b64
FB
1177 sign = 0;
1178 } else {
1179 val = -val;
de6d9b64
FB
1180 sign = 1;
1181 }
a9c68306 1182#endif
3bf43d42
MN
1183 val--;
1184 code = (val >> bit_size) + 1;
1185 bits = val & (range - 1);
de6d9b64
FB
1186
1187 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1188 if (bit_size > 0) {
1189 put_bits(&s->pb, bit_size, bits);
1190 }
1191 }
3a3d3a42 1192
de6d9b64
FB
1193}
1194
6dbd39fe
J
1195/* Encode MV differences on H.263+ with Unrestricted MV mode */
1196static void h263p_encode_umotion(MpegEncContext * s, int val)
1197{
1198 short sval = 0;
1199 short i = 0;
1200 short n_bits = 0;
1201 short temp_val;
1202 int code = 0;
1203 int tcode;
1204
1205 if ( val == 0)
1206 put_bits(&s->pb, 1, 1);
1207 else if (val == 1)
1208 put_bits(&s->pb, 3, 0);
1209 else if (val == -1)
1210 put_bits(&s->pb, 3, 2);
1211 else {
1212
1213 sval = ((val < 0) ? (short)(-val):(short)val);
1214 temp_val = sval;
1215
1216 while (temp_val != 0) {
1217 temp_val = temp_val >> 1;
1218 n_bits++;
1219 }
1220
1221 i = n_bits - 1;
1222 while (i > 0) {
1223 tcode = (sval & (1 << (i-1))) >> (i-1);
1224 tcode = (tcode << 1) | 1;
1225 code = (code << 2) | tcode;
1226 i--;
1227 }
1228 code = ((code << 1) | (val < 0)) << 1;
1229 put_bits(&s->pb, (2*n_bits)+1, code);
1230 //printf("\nVal = %d\tCode = %d", sval, code);
1231 }
1232}
1233
45870f57
MN
1234static void init_mv_penalty_and_fcode(MpegEncContext *s)
1235{
1236 int f_code;
1237 int mv;
bbed9259
MN
1238
1239 if(mv_penalty==NULL)
1240 mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1241
45870f57
MN
1242 for(f_code=1; f_code<=MAX_FCODE; f_code++){
1243 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1244 int len;
1245
1246 if(mv==0) len= mvtab[0][1];
1247 else{
1248 int val, bit_size, range, code;
1249
1250 bit_size = s->f_code - 1;
1251 range = 1 << bit_size;
1252
1253 val=mv;
1254 if (val < 0)
1255 val = -val;
1256 val--;
1257 code = (val >> bit_size) + 1;
1258 if(code<33){
1259 len= mvtab[code][1] + 1 + bit_size;
1260 }else{
1261 len= mvtab[32][1] + 2 + bit_size;
1262 }
1263 }
1264
1265 mv_penalty[f_code][mv+MAX_MV]= len;
1266 }
1267 }
45870f57
MN
1268
1269 for(f_code=MAX_FCODE; f_code>0; f_code--){
1270 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1271 fcode_tab[mv+MAX_MV]= f_code;
1272 }
1273 }
9d2a0355
MN
1274
1275 for(mv=0; mv<MAX_MV*2+1; mv++){
1276 umv_fcode_tab[mv]= 1;
1277 }
45870f57 1278}
bbed9259 1279#endif
45870f57 1280
20695ec9 1281static void init_uni_dc_tab(void)
2a164b25
MN
1282{
1283 int level, uni_code, uni_len;
1284
3bf43d42 1285 for(level=-256; level<256; level++){
2a164b25
MN
1286 int size, v, l;
1287 /* find number of bits */
1288 size = 0;
1289 v = abs(level);
1290 while (v) {
1291 v >>= 1;
1292 size++;
1293 }
1294
1295 if (level < 0)
1296 l= (-level) ^ ((1 << size) - 1);
1297 else
1298 l= level;
1299
1300 /* luminance */
1301 uni_code= DCtab_lum[size][0];
1302 uni_len = DCtab_lum[size][1];
1303
1304 if (size > 0) {
1305 uni_code<<=size; uni_code|=l;
1306 uni_len+=size;
1307 if (size > 8){
1308 uni_code<<=1; uni_code|=1;
1309 uni_len++;
1310 }
1311 }
1312 uni_DCtab_lum[level+256][0]= uni_code;
1313 uni_DCtab_lum[level+256][1]= uni_len;
1314
1315 /* chrominance */
1316 uni_code= DCtab_chrom[size][0];
1317 uni_len = DCtab_chrom[size][1];
1318
1319 if (size > 0) {
1320 uni_code<<=size; uni_code|=l;
1321 uni_len+=size;
1322 if (size > 8){
1323 uni_code<<=1; uni_code|=1;
1324 uni_len++;
1325 }
1326 }
1327 uni_DCtab_chrom[level+256][0]= uni_code;
1328 uni_DCtab_chrom[level+256][1]= uni_len;
1329
1330 }
1331}
1332
bbed9259 1333#ifdef CONFIG_ENCODERS
3db48188
MN
1334static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
1335 int slevel, run, last;
1336
1337 assert(MAX_LEVEL >= 64);
1338 assert(MAX_RUN >= 63);
1339
1340 for(slevel=-64; slevel<64; slevel++){
1341 if(slevel==0) continue;
1342 for(run=0; run<64; run++){
1343 for(last=0; last<=1; last++){
1344 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1345 int level= slevel < 0 ? -slevel : slevel;
1346 int sign= slevel < 0 ? 1 : 0;
1347 int bits, len, code;
1348 int level1, run1;
1349
1350 len_tab[index]= 100;
1351
1352 /* ESC0 */
1353 code= get_rl_index(rl, last, run, level);
1354 bits= rl->table_vlc[code][0];
1355 len= rl->table_vlc[code][1];
1356 bits=bits*2+sign; len++;
1357
1358 if(code!=rl->n && len < len_tab[index]){
1359 bits_tab[index]= bits;
1360 len_tab [index]= len;
1361 }
1362#if 1
1363 /* ESC1 */
1364 bits= rl->table_vlc[rl->n][0];
1365 len= rl->table_vlc[rl->n][1];
1366 bits=bits*2; len++; //esc1
1367 level1= level - rl->max_level[last][run];
1368 if(level1>0){
1369 code= get_rl_index(rl, last, run, level1);
1370 bits<<= rl->table_vlc[code][1];
1371 len += rl->table_vlc[code][1];
1372 bits += rl->table_vlc[code][0];
1373 bits=bits*2+sign; len++;
1374
1375 if(code!=rl->n && len < len_tab[index]){
1376 bits_tab[index]= bits;
1377 len_tab [index]= len;
1378 }
1379 }
1380#endif
1381#if 1
1382 /* ESC2 */
1383 bits= rl->table_vlc[rl->n][0];
1384 len= rl->table_vlc[rl->n][1];
1385 bits=bits*4+2; len+=2; //esc2
1386 run1 = run - rl->max_run[last][level] - 1;
1387 if(run1>=0){
1388 code= get_rl_index(rl, last, run1, level);
1389 bits<<= rl->table_vlc[code][1];
1390 len += rl->table_vlc[code][1];
1391 bits += rl->table_vlc[code][0];
1392 bits=bits*2+sign; len++;
1393
1394 if(code!=rl->n && len < len_tab[index]){
1395 bits_tab[index]= bits;
1396 len_tab [index]= len;
1397 }
1398 }
1399#endif
1400 /* ESC3 */
1401 bits= rl->table_vlc[rl->n][0];
1402 len = rl->table_vlc[rl->n][1];
1403 bits=bits*4+3; len+=2; //esc3
1404 bits=bits*2+last; len++;
1405 bits=bits*64+run; len+=6;
1406 bits=bits*2+1; len++; //marker
1407 bits=bits*4096+(slevel&0xfff); len+=12;
1408 bits=bits*2+1; len++; //marker
1409
1410 if(len < len_tab[index]){
1411 bits_tab[index]= bits;
1412 len_tab [index]= len;
1413 }
1414 }
1415 }
1416 }
1417}
1418
45870f57 1419void h263_encode_init(MpegEncContext *s)
de6d9b64
FB
1420{
1421 static int done = 0;
1422
1423 if (!done) {
1424 done = 1;
2a164b25
MN
1425
1426 init_uni_dc_tab();
1427
de6d9b64
FB
1428 init_rl(&rl_inter);
1429 init_rl(&rl_intra);
ef5b1b5a 1430 init_rl(&rl_intra_aic);
3db48188
MN
1431
1432 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1433 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
45870f57
MN
1434
1435 init_mv_penalty_and_fcode(s);
de6d9b64 1436 }
1457ab52 1437 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
45870f57 1438
9d2a0355 1439 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
d7e9533a
MN
1440 switch(s->codec_id){
1441 case CODEC_ID_MPEG4:
1442 s->fcode_tab= fcode_tab;
1443 s->min_qcoeff= -2048;
1444 s->max_qcoeff= 2047;
477ab036
MN
1445 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
1446 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
1447 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
1448 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1449 s->ac_esc_length= 7+2+1+6+1+12+1;
d7e9533a
MN
1450 break;
1451 case CODEC_ID_H263P:
1452 s->fcode_tab= umv_fcode_tab;
1453 s->min_qcoeff= -128;
1454 s->max_qcoeff= 127;
1455 break;
8f8402e4 1456 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
d7e9533a
MN
1457 default: //nothing needed default table allready set in mpegvideo.c
1458 s->min_qcoeff= -128;
1459 s->max_qcoeff= 127;
8f8402e4
MN
1460 s->y_dc_scale_table=
1461 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
d7e9533a
MN
1462 }
1463
87f8cab4
MN
1464 if(s->mpeg_quant){
1465 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1466 s->inter_quant_bias= 0;
1467 }else{
1468 s->intra_quant_bias=0;
1469 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1470 }
de6d9b64
FB
1471}
1472
1473static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1474{
ef5b1b5a
J
1475 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1476 RLTable *rl;
de6d9b64 1477
ef5b1b5a
J
1478 rl = &rl_inter;
1479 if (s->mb_intra && !s->h263_aic) {
81401c1f
J
1480 /* DC coef */
1481 level = block[0];
de6d9b64
FB
1482 /* 255 cannot be represented, so we clamp */
1483 if (level > 254) {
1484 level = 254;
1485 block[0] = 254;
1486 }
81401c1f
J
1487 /* 0 cannot be represented also */
1488 else if (!level) {
1489 level = 1;
1490 block[0] = 1;
1491 }
1492 if (level == 128)
1493 put_bits(&s->pb, 8, 0xff);
1494 else
1495 put_bits(&s->pb, 8, level & 0xff);
1496 i = 1;
de6d9b64 1497 } else {
81401c1f 1498 i = 0;
ef5b1b5a
J
1499 if (s->h263_aic && s->mb_intra)
1500 rl = &rl_intra_aic;
de6d9b64 1501 }
ef5b1b5a 1502
de6d9b64
FB
1503 /* AC coefs */
1504 last_index = s->block_last_index[n];
1505 last_non_zero = i - 1;
1506 for (; i <= last_index; i++) {
2ad1516a 1507 j = s->intra_scantable.permutated[i];
ef5b1b5a
J
1508 level = block[j];
1509 if (level) {
1510 run = i - last_non_zero - 1;
1511 last = (i == last_index);
1512 sign = 0;
1513 slevel = level;
1514 if (level < 0) {
1515 sign = 1;
1516 level = -level;
1517 }
de6d9b64
FB
1518 code = get_rl_index(rl, last, run, level);
1519 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1520 if (code == rl->n) {
1521 put_bits(&s->pb, 1, last);
1522 put_bits(&s->pb, 6, run);
1523 put_bits(&s->pb, 8, slevel & 0xff);
1524 } else {
1525 put_bits(&s->pb, 1, sign);
1526 }
ef5b1b5a
J
1527 last_non_zero = i;
1528 }
de6d9b64
FB
1529 }
1530}
bbed9259 1531#endif
de6d9b64
FB
1532
1533/***************************************************/
4d2858de
MN
1534/**
1535 * add mpeg4 stuffing bits (01...1)
1536 */
92073d01 1537void ff_mpeg4_stuffing(PutBitContext * pbc)
6f91bcd1
MN
1538{
1539 int length;
1540 put_bits(pbc, 1, 0);
1541 length= (-get_bit_count(pbc))&7;
92073d01 1542 if(length) put_bits(pbc, length, (1<<length)-1);
6f91bcd1
MN
1543}
1544
91029be7
MN
1545/* must be called before writing the header */
1546void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1547 int time_div, time_mod;
1548
1549 if(s->pict_type==I_TYPE){ //we will encode a vol header
1550 s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1551 if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1552
1553 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1554 }
15415af4 1555
1e491e29
MN
1556 if(s->current_picture.pts)
1557 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
15415af4
MN
1558 else
1559 s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
91029be7
MN
1560 time_div= s->time/s->time_increment_resolution;
1561 time_mod= s->time%s->time_increment_resolution;
1562
1563 if(s->pict_type==B_TYPE){
bea669e5 1564 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
91029be7
MN
1565 }else{
1566 s->last_time_base= s->time_base;
1567 s->time_base= time_div;
1568 s->pp_time= s->time - s->last_non_b_time;
1569 s->last_non_b_time= s->time;
1570 }
1571}
1572
41773b73
MN
1573static void mpeg4_encode_gop_header(MpegEncContext * s){
1574 int hours, minutes, seconds;
1575
1576 put_bits(&s->pb, 16, 0);
1577 put_bits(&s->pb, 16, GOP_STARTCODE);
1578
1579 seconds= s->time/s->time_increment_resolution;
1580 minutes= seconds/60; seconds %= 60;
1581 hours= minutes/60; minutes %= 60;
1582 hours%=24;
1583
1584 put_bits(&s->pb, 5, hours);
1585 put_bits(&s->pb, 6, minutes);
1586 put_bits(&s->pb, 1, 1);
1587 put_bits(&s->pb, 6, seconds);
1588
1589 put_bits(&s->pb, 1, 0); //closed gov == NO
1590 put_bits(&s->pb, 1, 0); //broken link == NO
1591
1592 ff_mpeg4_stuffing(&s->pb);
1593}
1594
1595static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1596 int profile_and_level_indication;
1597 int vo_ver_id;
1598
1599 if(s->max_b_frames || s->quarter_sample){
1600 profile_and_level_indication= 0xF1; // adv simple level 1
1601 vo_ver_id= 5;
1602 }else{
1603 profile_and_level_indication= 0x01; // simple level 1
1604 vo_ver_id= 1;
1605 }
1606 //FIXME levels
1607
1608 put_bits(&s->pb, 16, 0);
1609 put_bits(&s->pb, 16, VOS_STARTCODE);
1610
1611 put_bits(&s->pb, 8, profile_and_level_indication);
1612
1613 put_bits(&s->pb, 16, 0);
1614 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1615
1616 put_bits(&s->pb, 1, 1);
1617 put_bits(&s->pb, 4, vo_ver_id);
1618 put_bits(&s->pb, 3, 1); //priority
1619
1620 put_bits(&s->pb, 4, 1); //visual obj type== video obj
1621
1622 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1623
1624 ff_mpeg4_stuffing(&s->pb);
1625}
1626
1627static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
de6d9b64 1628{
41773b73 1629 int vo_ver_id;
4b1f4f23 1630 char buf[255];
1ff662cc 1631
41773b73
MN
1632 if(s->max_b_frames || s->quarter_sample){
1633 vo_ver_id= 5;
f8af5cb5
MN
1634 s->vo_type= ADV_SIMPLE_VO_TYPE;
1635 }else{
41773b73 1636 vo_ver_id= 1;
f8af5cb5
MN
1637 s->vo_type= SIMPLE_VO_TYPE;
1638 }
1ff662cc 1639
10cd5815 1640 put_bits(&s->pb, 16, 0);
41773b73 1641 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
10cd5815 1642 put_bits(&s->pb, 16, 0);
41773b73 1643 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
10cd5815
MN
1644
1645 put_bits(&s->pb, 1, 0); /* random access vol */
1ff662cc 1646 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
10cd5815
MN
1647 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
1648 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
1649 put_bits(&s->pb, 3, 1); /* is obj layer priority */
5d3cea3a 1650
58b0b0dd 1651 float_aspect_to_info(s, s->avctx->aspect_ratio);
5d3cea3a
MN
1652
1653 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
050fe8ba
AB
1654 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1655 {
1656 put_bits(&s->pb, 8, s->aspected_width);
1657 put_bits(&s->pb, 8, s->aspected_height);
1658 }
1ff662cc
MN
1659
1660 if(s->low_delay){
1661 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1c2a8c7f 1662 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1ff662cc
MN
1663 put_bits(&s->pb, 1, s->low_delay);
1664 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1665 }else{
1666 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
1667 }
1668
10cd5815
MN
1669 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1670 put_bits(&s->pb, 1, 1); /* marker bit */
9dbcbd92 1671
9dbcbd92 1672 put_bits(&s->pb, 16, s->time_increment_resolution);
10cd5815
MN
1673 if (s->time_increment_bits < 1)
1674 s->time_increment_bits = 1;
1675 put_bits(&s->pb, 1, 1); /* marker bit */
1676 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1677 put_bits(&s->pb, 1, 1); /* marker bit */
1678 put_bits(&s->pb, 13, s->width); /* vol width */
1679 put_bits(&s->pb, 1, 1); /* marker bit */
1680 put_bits(&s->pb, 13, s->height); /* vol height */
1681 put_bits(&s->pb, 1, 1); /* marker bit */
fcb48651 1682 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
10cd5815
MN
1683 put_bits(&s->pb, 1, 1); /* obmc disable */
1684 if (vo_ver_id == 1) {
1685 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
41773b73 1686 }else{
10cd5815
MN
1687 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
1688 }
4d2858de
MN
1689
1690 s->quant_precision=5;
1691 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
87f8cab4
MN
1692 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1693 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
1694
10cd5815 1695 if (vo_ver_id != 1)
1457ab52 1696 put_bits(&s->pb, 1, s->quarter_sample);
10cd5815 1697 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
92073d01
MN
1698 s->resync_marker= s->rtp_mode;
1699 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1700 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1701 if(s->data_partitioning){
1702 put_bits(&s->pb, 1, 0); /* no rvlc */
1703 }
1704
10cd5815
MN
1705 if (vo_ver_id != 1){
1706 put_bits(&s->pb, 1, 0); /* newpred */
1707 put_bits(&s->pb, 1, 0); /* reduced res vop */
1708 }
1709 put_bits(&s->pb, 1, 0); /* scalability */
5596c60c 1710
92073d01 1711 ff_mpeg4_stuffing(&s->pb);
49c9325f 1712
5596c60c
MN
1713 /* user data */
1714 if(!ff_bit_exact){
1715 put_bits(&s->pb, 16, 0);
1716 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1717 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1718 put_string(&s->pb, buf);
1719 ff_mpeg4_stuffing(&s->pb);
1720 }
10cd5815
MN
1721}
1722
1723/* write mpeg4 VOP header */
1724void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1725{
9dbcbd92
MN
1726 int time_incr;
1727 int time_div, time_mod;
1728
92073d01 1729 if(s->pict_type==I_TYPE){
70ac76c0 1730 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
41773b73
MN
1731 mpeg4_encode_visual_object_header(s);
1732 mpeg4_encode_vol_header(s, 0, 0);
41773b73
MN
1733 }
1734 mpeg4_encode_gop_header(s);
92073d01 1735 }
9dbcbd92 1736
4d2858de
MN
1737 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1738
9dbcbd92
MN
1739//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1740
17592475 1741 put_bits(&s->pb, 16, 0); /* vop header */
41773b73 1742 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
de6d9b64 1743 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
9dbcbd92 1744
91029be7
MN
1745 time_div= s->time/s->time_increment_resolution;
1746 time_mod= s->time%s->time_increment_resolution;
9dbcbd92
MN
1747 time_incr= time_div - s->last_time_base;
1748 while(time_incr--)
1749 put_bits(&s->pb, 1, 1);
1750
de6d9b64
FB
1751 put_bits(&s->pb, 1, 0);
1752
1753 put_bits(&s->pb, 1, 1); /* marker */
9dbcbd92 1754 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
de6d9b64
FB
1755 put_bits(&s->pb, 1, 1); /* marker */
1756 put_bits(&s->pb, 1, 1); /* vop coded */
10cd5815
MN
1757 if ( s->pict_type == P_TYPE
1758 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
de6d9b64
FB
1759 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1760 }
1761 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
fcb48651
MN
1762 if(!s->progressive_sequence){
1763 put_bits(&s->pb, 1, s->top_field_first);
1764 put_bits(&s->pb, 1, s->alternate_scan);
1765 }
10cd5815 1766 //FIXME sprite stuff
de6d9b64
FB
1767
1768 put_bits(&s->pb, 5, s->qscale);
1769
1770 if (s->pict_type != I_TYPE)
1771 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
10cd5815
MN
1772 if (s->pict_type == B_TYPE)
1773 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
de6d9b64 1774 // printf("****frame %d\n", picture_number);
8f8402e4
MN
1775
1776 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1777 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
b5a093b3
MN
1778 s->h_edge_pos= s->width;
1779 s->v_edge_pos= s->height;
de6d9b64
FB
1780}
1781
4d2858de
MN
1782/**
1783 * change qscale by given dquant and update qscale dependant variables.
1784 */
5482970b 1785static void change_qscale(MpegEncContext * s, int dquant)
de6d9b64 1786{
5482970b
MN
1787 s->qscale += dquant;
1788
1789 if (s->qscale < 1)
1790 s->qscale = 1;
1791 else if (s->qscale > 31)
1792 s->qscale = 31;
1793
8f8402e4
MN
1794 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1795 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
de6d9b64
FB
1796}
1797
4d2858de 1798static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
de6d9b64 1799{
4278e7a6 1800 int a, b, c, wrap, pred, scale;
de6d9b64 1801 UINT16 *dc_val;
e7650bec 1802 int dummy;
de6d9b64
FB
1803
1804 /* find prediction */
1805 if (n < 4) {
de6d9b64
FB
1806 scale = s->y_dc_scale;
1807 } else {
de6d9b64
FB
1808 scale = s->c_dc_scale;
1809 }
4278e7a6
MN
1810 wrap= s->block_wrap[n];
1811 dc_val = s->dc_val[0] + s->block_index[n];
de6d9b64
FB
1812
1813 /* B C
1814 * A X
1815 */
4278e7a6
MN
1816 a = dc_val[ - 1];
1817 b = dc_val[ - 1 - wrap];
1818 c = dc_val[ - wrap];
de6d9b64 1819
4d2858de
MN
1820 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
1821 if(s->first_slice_line && n!=3){
1822 if(n!=2) b=c= 1024;
1823 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
1824 }
1825 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
1826 if(n==0 || n==4 || n==5)
1827 b=1024;
1828 }
1829
de6d9b64
FB
1830 if (abs(a - b) < abs(b - c)) {
1831 pred = c;
1832 *dir_ptr = 1; /* top */
1833 } else {
1834 pred = a;
1835 *dir_ptr = 0; /* left */
1836 }
1837 /* we assume pred is positive */
d6231b9e
MN
1838#ifdef ARCH_X86
1839 asm volatile (
1840 "xorl %%edx, %%edx \n\t"
1841 "mul %%ecx \n\t"
1842 : "=d" (pred), "=a"(dummy)
1843 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1844 );
1845#else
de6d9b64 1846 pred = (pred + (scale >> 1)) / scale;
d6231b9e 1847#endif
de6d9b64
FB
1848
1849 /* prepare address for prediction update */
4278e7a6 1850 *dc_val_ptr = &dc_val[0];
de6d9b64
FB
1851
1852 return pred;
1853}
1854
d962f6fd 1855void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
de6d9b64
FB
1856 int dir)
1857{
4278e7a6 1858 int i;
de6d9b64 1859 INT16 *ac_val, *ac_val1;
1e491e29 1860 int8_t * const qscale_table= s->current_picture.qscale_table;
de6d9b64
FB
1861
1862 /* find prediction */
4278e7a6 1863 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
de6d9b64
FB
1864 ac_val1 = ac_val;
1865 if (s->ac_pred) {
1866 if (dir == 0) {
3e6a20a0 1867 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
de6d9b64
FB
1868 /* left prediction */
1869 ac_val -= 16;
3e6a20a0 1870
1e491e29 1871 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
3e6a20a0
MN
1872 /* same qscale */
1873 for(i=1;i<8;i++) {
2ad1516a 1874 block[s->idct_permutation[i<<3]] += ac_val[i];
3e6a20a0
MN
1875 }
1876 }else{
1877 /* different qscale, we must rescale */
1878 for(i=1;i<8;i++) {
1e491e29 1879 block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
3e6a20a0 1880 }
de6d9b64
FB
1881 }
1882 } else {
3e6a20a0 1883 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
de6d9b64 1884 /* top prediction */
4278e7a6 1885 ac_val -= 16 * s->block_wrap[n];
3e6a20a0 1886
1e491e29 1887 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
3e6a20a0
MN
1888 /* same qscale */
1889 for(i=1;i<8;i++) {
2ad1516a 1890 block[s->idct_permutation[i]] += ac_val[i + 8];
3e6a20a0
MN
1891 }
1892 }else{
1893 /* different qscale, we must rescale */
1894 for(i=1;i<8;i++) {
1e491e29 1895 block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
3e6a20a0 1896 }
de6d9b64
FB
1897 }
1898 }
1899 }
1900 /* left copy */
1901 for(i=1;i<8;i++)
2ad1516a 1902 ac_val1[i ] = block[s->idct_permutation[i<<3]];
d930ef19 1903
de6d9b64
FB
1904 /* top copy */
1905 for(i=1;i<8;i++)
2ad1516a 1906 ac_val1[8 + i] = block[s->idct_permutation[i ]];
d930ef19 1907
de6d9b64
FB
1908}
1909
d6231b9e
MN
1910static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1911 int dir)
de6d9b64 1912{
4278e7a6 1913 int i;
d6231b9e 1914 INT16 *ac_val;
1e491e29 1915 int8_t * const qscale_table= s->current_picture.qscale_table;
de6d9b64 1916
d6231b9e 1917 /* find prediction */
4278e7a6 1918 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
d6231b9e
MN
1919
1920 if (dir == 0) {
99609036 1921 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
d6231b9e
MN
1922 /* left prediction */
1923 ac_val -= 16;
1e491e29 1924 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
99609036
MN
1925 /* same qscale */
1926 for(i=1;i<8;i++) {
2ad1516a 1927 block[s->idct_permutation[i<<3]] -= ac_val[i];
99609036
MN
1928 }
1929 }else{
1930 /* different qscale, we must rescale */
1931 for(i=1;i<8;i++) {
1e491e29 1932 block[s->idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
99609036 1933 }
d6231b9e
MN
1934 }
1935 } else {
99609036 1936 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
d6231b9e 1937 /* top prediction */
4278e7a6 1938 ac_val -= 16 * s->block_wrap[n];
1e491e29 1939 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
99609036
MN
1940 /* same qscale */
1941 for(i=1;i<8;i++) {
2ad1516a 1942 block[s->idct_permutation[i]] -= ac_val[i + 8];
99609036
MN
1943 }
1944 }else{
1945 /* different qscale, we must rescale */
1946 for(i=1;i<8;i++) {
1e491e29 1947 block[s->idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
99609036 1948 }
d6231b9e 1949 }
de6d9b64 1950 }
d6231b9e
MN
1951}
1952
92073d01 1953static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
d6231b9e 1954{
2a164b25 1955#if 1
92073d01 1956// if(level<-255 || level>255) printf("dc overflow\n");
2a164b25
MN
1957 level+=256;
1958 if (n < 4) {
1959 /* luminance */
92073d01 1960 put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
2a164b25
MN
1961 } else {
1962 /* chrominance */
92073d01 1963 put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
2a164b25
MN
1964 }
1965#else
d6231b9e 1966 int size, v;
de6d9b64
FB
1967 /* find number of bits */
1968 size = 0;
1969 v = abs(level);
1970 while (v) {
1971 v >>= 1;
1972 size++;
1973 }
1974
1975 if (n < 4) {
1976 /* luminance */
1977 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1978 } else {
1979 /* chrominance */
1980 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1981 }
1982
1983 /* encode remaining bits */
1984 if (size > 0) {
1985 if (level < 0)
1986 level = (-level) ^ ((1 << size) - 1);
1987 put_bits(&s->pb, size, level);
1988 if (size > 8)
1989 put_bits(&s->pb, 1, 1);
1990 }
2a164b25 1991#endif
de6d9b64 1992}
bbed9259 1993#ifdef CONFIG_ENCODERS
3db48188 1994static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
92073d01 1995 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
de6d9b64 1996{
d2975f8d
MN
1997 int i, last_non_zero;
1998#if 0 //variables for the outcommented version
1999 int code, sign, last;
2000#endif
de6d9b64 2001 const RLTable *rl;
3db48188
MN
2002 UINT32 *bits_tab;
2003 UINT8 *len_tab;
2004 const int last_index = s->block_last_index[n];
de6d9b64 2005
3db48188 2006 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
de6d9b64 2007 /* mpeg4 based DC predictor */
92073d01 2008 mpeg4_encode_dc(dc_pb, intra_dc, n);
3db48188 2009 if(last_index<1) return;
de6d9b64
FB
2010 i = 1;
2011 rl = &rl_intra;
3db48188
MN
2012 bits_tab= uni_mpeg4_intra_rl_bits;
2013 len_tab = uni_mpeg4_intra_rl_len;
de6d9b64 2014 } else {
3db48188 2015 if(last_index<0) return;
de6d9b64
FB
2016 i = 0;
2017 rl = &rl_inter;
3db48188
MN
2018 bits_tab= uni_mpeg4_inter_rl_bits;
2019 len_tab = uni_mpeg4_inter_rl_len;
de6d9b64
FB
2020 }
2021
2022 /* AC coefs */
de6d9b64 2023 last_non_zero = i - 1;
3db48188
MN
2024#if 1
2025 for (; i < last_index; i++) {
2026 int level = block[ scan_table[i] ];
de6d9b64 2027 if (level) {
3db48188
MN
2028 int run = i - last_non_zero - 1;
2029 level+=64;
2030 if((level&(~127)) == 0){
2031 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2032 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2033 }else{ //ESC3
2034 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2035 }
2036 last_non_zero = i;
2037 }
2038 }
2039 /*if(i<=last_index)*/{
2040 int level = block[ scan_table[i] ];
2041 int run = i - last_non_zero - 1;
2042 level+=64;
2043 if((level&(~127)) == 0){
2044 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2045 put_bits(ac_pb, len_tab[index], bits_tab[index]);
2046 }else{ //ESC3
2047 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2048 }
2049 }
2050#else
2051 for (; i <= last_index; i++) {
2052 const int slevel = block[ scan_table[i] ];
2053 if (slevel) {
2054 int level;
2055 int run = i - last_non_zero - 1;
de6d9b64
FB
2056 last = (i == last_index);
2057 sign = 0;
3db48188 2058 level = slevel;
de6d9b64
FB
2059 if (level < 0) {
2060 sign = 1;
2061 level = -level;
2062 }
2063 code = get_rl_index(rl, last, run, level);
92073d01 2064 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
de6d9b64
FB
2065 if (code == rl->n) {
2066 int level1, run1;
2067 level1 = level - rl->max_level[last][run];
2068 if (level1 < 1)
2069 goto esc2;
2070 code = get_rl_index(rl, last, run, level1);
2071 if (code == rl->n) {
2072 esc2:
92073d01 2073 put_bits(ac_pb, 1, 1);
de6d9b64
FB
2074 if (level > MAX_LEVEL)
2075 goto esc3;
2076 run1 = run - rl->max_run[last][level] - 1;
2077 if (run1 < 0)
2078 goto esc3;
2079 code = get_rl_index(rl, last, run1, level);
2080 if (code == rl->n) {
2081 esc3:
2082 /* third escape */
92073d01
MN
2083 put_bits(ac_pb, 1, 1);
2084 put_bits(ac_pb, 1, last);
2085 put_bits(ac_pb, 6, run);
2086 put_bits(ac_pb, 1, 1);
2087 put_bits(ac_pb, 12, slevel & 0xfff);
2088 put_bits(ac_pb, 1, 1);
de6d9b64
FB
2089 } else {
2090 /* second escape */
92073d01
MN
2091 put_bits(ac_pb, 1, 0);
2092 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2093 put_bits(ac_pb, 1, sign);
de6d9b64
FB
2094 }
2095 } else {
2096 /* first escape */
92073d01
MN
2097 put_bits(ac_pb, 1, 0);
2098 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2099 put_bits(ac_pb, 1, sign);
de6d9b64
FB
2100 }
2101 } else {
92073d01 2102 put_bits(ac_pb, 1, sign);
de6d9b64
FB
2103 }
2104 last_non_zero = i;
2105 }
2106 }
3db48188 2107#endif
de6d9b64 2108}
1457ab52
MN
2109
2110static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2111 UINT8 *scan_table)
2112{
2113 int i, last_non_zero;
2114 const RLTable *rl;
2115 UINT8 *len_tab;
2116 const int last_index = s->block_last_index[n];
2117 int len=0;
2118
2119 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2120 /* mpeg4 based DC predictor */
2121 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2122 if(last_index<1) return len;
2123 i = 1;
2124 rl = &rl_intra;
2125 len_tab = uni_mpeg4_intra_rl_len;
2126 } else {
2127 if(last_index<0) return 0;
2128 i = 0;
2129 rl = &rl_inter;
2130 len_tab = uni_mpeg4_inter_rl_len;
2131 }
2132
2133 /* AC coefs */
2134 last_non_zero = i - 1;
2135 for (; i < last_index; i++) {
2136 int level = block[ scan_table[i] ];
2137 if (level) {
2138 int run = i - last_non_zero - 1;
2139 level+=64;
2140 if((level&(~127)) == 0){
2141 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2142 len += len_tab[index];
2143 }else{ //ESC3
2144 len += 7+2+1+6+1+12+1;
2145 }
2146 last_non_zero = i;
2147 }
2148 }
2149 /*if(i<=last_index)*/{
2150 int level = block[ scan_table[i] ];
2151 int run = i - last_non_zero - 1;
2152 level+=64;
2153 if((level&(~127)) == 0){
2154 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2155 len += len_tab[index];
2156 }else{ //ESC3
2157 len += 7+2+1+6+1+12+1;
2158 }
2159 }
2160
2161 return len;
2162}
2163
bbed9259 2164#endif
de6d9b64
FB
2165
2166
2167/***********************************************/
2168/* decoding */
2169
2170static VLC intra_MCBPC_vlc;
2171static VLC inter_MCBPC_vlc;
2172static VLC cbpy_vlc;
2173static VLC mv_vlc;
2174static VLC dc_lum, dc_chrom;
73c8e514 2175static VLC sprite_trajectory;
6f91bcd1 2176static VLC mb_type_b_vlc;
de6d9b64
FB
2177
2178void init_rl(RLTable *rl)
2179{
2180 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
2181 UINT8 index_run[MAX_RUN+1];
2182 int last, run, level, start, end, i;
2183
2184 /* compute max_level[], max_run[] and index_run[] */
2185 for(last=0;last<2;last++) {
2186 if (last == 0) {
2187 start = 0;
2188 end = rl->last;
2189 } else {
2190 start = rl->last;
2191 end = rl->n;
2192 }
2193
2194 memset(max_level, 0, MAX_RUN + 1);
2195 memset(max_run, 0, MAX_LEVEL + 1);
2196 memset(index_run, rl->n, MAX_RUN + 1);
2197 for(i=start;i<end;i++) {
2198 run = rl->table_run[i];
2199 level = rl->table_level[i];
2200 if (index_run[run] == rl->n)
2201 index_run[run] = i;
2202 if (level > max_level[run])
2203 max_level[run] = level;
2204 if (run > max_run[level])
2205 max_run[level] = run;
2206 }
6000abfa 2207 rl->max_level[last] = av_malloc(MAX_RUN + 1);
de6d9b64 2208 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
6000abfa 2209 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
de6d9b64 2210 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
6000abfa 2211 rl->index_run[last] = av_malloc(MAX_RUN + 1);
de6d9b64
FB
2212 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
2213 }
2214}
2215
2216void init_vlc_rl(RLTable *rl)
2217{
45a82edb
MN
2218 int i, q;
2219
de6d9b64
FB
2220 init_vlc(&rl->vlc, 9, rl->n + 1,
2221 &rl->table_vlc[0][1], 4, 2,
2222 &rl->table_vlc[0][0], 4, 2);
45a82edb
MN
2223
2224
2225 for(q=0; q<32; q++){
2226 int qmul= q*2;
2227 int qadd= (q-1)|1;
2228
2229 if(q==0){
2230 qmul=1;
2231 qadd=0;
2232 }
2233
2234 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2235 for(i=0; i<rl->vlc.table_size; i++){
2236 int code= rl->vlc.table[i][0];
2237 int len = rl->vlc.table[i][1];
2238 int level, run;
2239
2240 if(len==0){ // illegal code
1a013246 2241 run= 66;
45a82edb
MN
2242 level= MAX_LEVEL;
2243 }else if(len<0){ //more bits needed
2244 run= 0;
2245 level= code;
2246 }else{
2247 if(code==rl->n){ //esc
1a013246 2248 run= 66;
45a82edb
MN
2249 level= 0;
2250 }else{
2251 run= rl->table_run [code] + 1;
2252 level= rl->table_level[code] * qmul + qadd;
2253 if(code >= rl->last) run+=192;
2254 }
2255 }
2256 rl->rl_vlc[q][i].len= len;
2257 rl->rl_vlc[q][i].level= level;
2258 rl->rl_vlc[q][i].run= run;
2259 }
2260 }
de6d9b64
FB
2261}
2262
2263/* init vlcs */
2264
2265/* XXX: find a better solution to handle static init */
2266void h263_decode_init_vlc(MpegEncContext *s)
2267{
2268 static int done = 0;
2269
2270 if (!done) {
2271 done = 1;
2272
edcf9890 2273 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
de6d9b64
FB
2274 intra_MCBPC_bits, 1, 1,
2275 intra_MCBPC_code, 1, 1);
edcf9890 2276 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
de6d9b64
FB
2277 inter_MCBPC_bits, 1, 1,
2278 inter_MCBPC_code, 1, 1);
edcf9890 2279 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
de6d9b64
FB
2280 &cbpy_tab[0][1], 2, 1,
2281 &cbpy_tab[0][0], 2, 1);
edcf9890 2282 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
de6d9b64
FB
2283 &mvtab[0][1], 2, 1,
2284 &mvtab[0][0], 2, 1);
2285 init_rl(&rl_inter);
2286 init_rl(&rl_intra);
d140623f 2287 init_rl(&rl_intra_aic);
de6d9b64
FB
2288 init_vlc_rl(&rl_inter);
2289 init_vlc_rl(&rl_intra);
d140623f 2290 init_vlc_rl(&rl_intra_aic);
c03a7172 2291 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
de6d9b64
FB
2292 &DCtab_lum[0][1], 2, 1,
2293 &DCtab_lum[0][0], 2, 1);
c03a7172 2294 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
de6d9b64
FB
2295 &DCtab_chrom[0][1], 2, 1,
2296 &DCtab_chrom[0][0], 2, 1);
edcf9890 2297 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
73c8e514
MN
2298 &sprite_trajectory_tab[0][1], 4, 2,
2299 &sprite_trajectory_tab[0][0], 4, 2);
edcf9890 2300 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
6f91bcd1
MN
2301 &mb_type_b_tab[0][1], 2, 1,
2302 &mb_type_b_tab[0][0], 2, 1);
de6d9b64 2303 }
4d2858de 2304}
fd7db0fd 2305
4d2858de
MN
2306/**
2307 * Get the GOB height based on picture height.
2308 */
2309int ff_h263_get_gob_height(MpegEncContext *s){
2310 if (s->height <= 400)
2311 return 1;
2312 else if (s->height <= 800)
2313 return 2;
2314 else
2315 return 4;
de6d9b64
FB
2316}
2317
4d2858de
MN
2318/**
2319 * decodes the group of blocks header.
2320 * @return <0 if an error occured
2321 */
2322static int h263_decode_gob_header(MpegEncContext *s)
de6d9b64 2323{
644d98a4 2324 unsigned int val, gfid;
4d2858de 2325 int left;
102d3908 2326
4949028f 2327 /* Check for GOB Start Code */
644d98a4 2328 val = show_bits(&s->gb, 16);
4d2858de
MN
2329 if(val)
2330 return -1;
2331
644d98a4 2332 /* We have a GBSC probably with GSTUFF */
4d2858de
MN
2333 skip_bits(&s->gb, 16); /* Drop the zeros */
2334 left= s->gb.size*8 - get_bits_count(&s->gb);
2335 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
2336 for(;left>13; left--){
2337 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2338 }
2339 if(left<=13)
2340 return -1;
2341
4949028f 2342#ifdef DEBUG
4d2858de 2343 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
102d3908 2344#endif
4d2858de
MN
2345 s->gob_number = get_bits(&s->gb, 5); /* GN */
2346 gfid = get_bits(&s->gb, 2); /* GFID */
2347 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2348 if(s->qscale==0)
2349 return -1;
2350 s->mb_x= 0;
2351 s->mb_y= s->gob_index* s->gob_number;
4949028f 2352#ifdef DEBUG
4d2858de 2353 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
4949028f 2354#endif
644d98a4 2355 return 0;
644d98a4
J
2356}
2357
49092244
MN
2358static inline void memsetw(short *tab, int val, int n)
2359{
2360 int i;
2361 for(i=0;i<n;i++)
2362 tab[i] = val;
2363}
2364
92073d01
MN
2365void ff_mpeg4_init_partitions(MpegEncContext *s)
2366{
2367 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2368 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
2369}
2370
2371void ff_mpeg4_merge_partitions(MpegEncContext *s)
2372{
2373 const int pb2_len = get_bit_count(&s->pb2 );
2374 const int tex_pb_len= get_bit_count(&s->tex_pb);
2375 const int bits= get_bit_count(&s->pb);
2376
2377 if(s->pict_type==I_TYPE){
2378 put_bits(&s->pb, 19, DC_MARKER);
2379 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
2380 s->i_tex_bits+= tex_pb_len;
2381 }else{
2382 put_bits(&s->pb, 17, MOTION_MARKER);
4d2858de 2383 s->misc_bits+=17 + pb2_len;
92073d01
MN
2384 s->mv_bits+= bits - s->last_bits;
2385 s->p_tex_bits+= tex_pb_len;
2386 }
2387
2388 flush_put_bits(&s->pb2);
2389 flush_put_bits(&s->tex_pb);
2390
2391 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
2392 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2393 s->last_bits= get_bit_count(&s->pb);
2394}
2395
4d2858de
MN
2396int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
2397 switch(s->pict_type){
2398 case I_TYPE:
2399 return 16;
2400 case P_TYPE:
2401 case S_TYPE:
2402 return s->f_code+15;
2403 case B_TYPE:
b8a78f41 2404 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
4d2858de
MN
2405 default:
2406 return -1;
2407 }
2408}
2409
92073d01 2410void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
49092244 2411{
49092244 2412 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
49092244 2413
92073d01 2414 ff_mpeg4_stuffing(&s->pb);
4d2858de 2415 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
92073d01
MN
2416 put_bits(&s->pb, 1, 1);
2417
2418 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
4d2858de 2419 put_bits(&s->pb, s->quant_precision, s->qscale);
92073d01
MN
2420 put_bits(&s->pb, 1, 0); /* no HEC */
2421}
49092244 2422
92073d01 2423/**
4d2858de
MN
2424 * check if the next stuff is a resync marker or the end.
2425 * @return 0 if not
92073d01 2426 */
4d2858de
MN
2427static inline int mpeg4_is_resync(MpegEncContext *s){
2428 const int bits_count= get_bits_count(&s->gb);
2429
2430 if(s->workaround_bugs&FF_BUG_NO_PADDING){
2431 return 0;
2432 }
2433
2434 if(bits_count + 8 >= s->gb.size*8){
2435 int v= show_bits(&s->gb, 8);
2436 v|= 0x7F >> (7-(bits_count&7));
2437
2438 if(v==0x7F)
2439 return 1;
2440 }else{
2441 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
2442 int len;
2443 GetBitContext gb= s->gb;
2444
2445 skip_bits(&s->gb, 1);
2446 align_get_bits(&s->gb);
2447
2448 for(len=0; len<32; len++){
2449 if(get_bits1(&s->gb)) break;
2450 }
2451
2452 s->gb= gb;
2453
2454 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
2455 return 1;
2456 }
2457 }
2458 return 0;
2459}
2460
2461/**
2462 * decodes the next video packet.
2463 * @return <0 if something went wrong
2464 */
2465static int mpeg4_decode_video_packet_header(MpegEncContext *s)
92073d01 2466{
92073d01 2467 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
4d2858de 2468 int header_extension=0, mb_num, len;
92073d01
MN
2469
2470 /* is there enough space left for a video packet + header */
4d2858de 2471 if( get_bits_count(&s->gb) > s->gb.size*8-20) return -1;
92073d01 2472
4d2858de
MN
2473 for(len=0; len<32; len++){
2474 if(get_bits1(&s->gb)) break;
49092244 2475 }
92073d01 2476
4d2858de
MN
2477 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2478 printf("marker does not match f_code\n");
92073d01
MN
2479 return -1;
2480 }
4d2858de 2481
49092244 2482 if(s->shape != RECT_SHAPE){
4d2858de 2483 header_extension= get_bits1(&s->gb);
49092244
MN
2484 //FIXME more stuff here
2485 }
2486
4d2858de
MN
2487 mb_num= get_bits(&s->gb, mb_num_bits);
2488 if(mb_num>=s->mb_num){
2489 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
92073d01
MN
2490 return -1;
2491 }
4d2858de
MN
2492 s->mb_x= mb_num % s->mb_width;
2493 s->mb_y= mb_num / s->mb_width;
49092244
MN
2494
2495 if(s->shape != BIN_ONLY_SHAPE){
4d2858de
MN
2496 int qscale= get_bits(&s->gb, s->quant_precision);
2497 if(qscale)
2498 s->qscale= qscale;
49092244
MN
2499 }
2500
2501 if(s->shape == RECT_SHAPE){
4d2858de 2502 header_extension= get_bits1(&s->gb);
49092244
MN
2503 }
2504 if(header_extension){
92073d01 2505 int time_increment;
49092244 2506 int time_incr=0;
92073d01 2507
4d2858de 2508 while (get_bits1(&s->gb) != 0)
49092244
MN
2509 time_incr++;
2510
4d2858de
MN
2511 check_marker(&s->gb, "before time_increment in video packed header");
2512 time_increment= get_bits(&s->gb, s->time_increment_bits);
2513 check_marker(&s->gb, "before vop_coding_type in video packed header");
49092244 2514
4d2858de 2515 skip_bits(&s->gb, 2); /* vop coding type */
49092244
MN
2516 //FIXME not rect stuff here
2517
2518 if(s->shape != BIN_ONLY_SHAPE){
4d2858de
MN
2519 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2520//FIXME dont just ignore everything
f56dd362 2521 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
49092244 2522 mpeg4_decode_sprite_trajectory(s);
f3cfadd5 2523 fprintf(stderr, "untested\n");
49092244
MN
2524 }
2525
2526 //FIXME reduced res stuff here
2527
2528 if (s->pict_type != I_TYPE) {
4d2858de 2529 int f_code = get_bits(&s->gb, 3); /* fcode_for */
f3cfadd5
MN
2530 if(f_code==0){
2531 printf("Error, video packet header damaged (f_code=0)\n");
49092244
MN
2532 }
2533 }
2534 if (s->pict_type == B_TYPE) {
4d2858de 2535 int b_code = get_bits(&s->gb, 3);
f3cfadd5
MN
2536 if(b_code==0){
2537 printf("Error, video packet header damaged (b_code=0)\n");
2538 }
49092244
MN
2539 }
2540 }
49092244
MN
2541 }
2542 //FIXME new-pred stuff
92073d01
MN
2543
2544//printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
2545
4d2858de 2546 return 0;
92073d01
MN
2547}
2548
2549void ff_mpeg4_clean_buffers(MpegEncContext *s)
2550{
2551 int c_wrap, c_xy, l_wrap, l_xy;
49092244
MN
2552
2553 l_wrap= s->block_wrap[0];
92073d01 2554 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
49092244 2555 c_wrap= s->block_wrap[4];
92073d01 2556 c_xy= s->mb_y*c_wrap + s->mb_x;
49092244 2557
4d2858de 2558#if 0
49092244 2559 /* clean DC */
92073d01
MN
2560 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
2561 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
2562 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
4d2858de 2563#endif
49092244
MN
2564
2565 /* clean AC */
92073d01
MN
2566 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
2567 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
2568 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
49092244
MN
2569
2570 /* clean MV */
92073d01
MN
2571 // we cant clear the MVs as they might be needed by a b frame
2572// memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
49092244 2573// memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
92073d01
MN
2574 s->last_mv[0][0][0]=
2575 s->last_mv[0][0][1]=
2576 s->last_mv[1][0][0]=
2577 s->last_mv[1][0][1]= 0;
2578}
2579
4d2858de
MN
2580/**
2581 * decodes the group of blocks / video packet header.
2582 * @return <0 if no resync found
2583 */
2584int ff_h263_resync(MpegEncContext *s){
2585 int left, ret;
92073d01 2586
4d2858de
MN
2587 if(s->codec_id==CODEC_ID_MPEG4)
2588 skip_bits1(&s->gb);
92073d01 2589
4d2858de 2590 align_get_bits(&s->gb);
92073d01 2591
4d2858de
MN
2592 if(show_bits(&s->gb, 16)==0){
2593 if(s->codec_id==CODEC_ID_MPEG4)
2594 ret= mpeg4_decode_video_packet_header(s);
2595 else
2596 ret= h263_decode_gob_header(s);
2597 if(ret>=0)
2598 return 0;
92073d01 2599 }
4d2858de
MN
2600 //ok, its not where its supposed to be ...
2601 s->gb= s->last_resync_gb;
2602 align_get_bits(&s->gb);
2603 left= s->gb.size*8 - get_bits_count(&s->gb);
92073d01 2604
4d2858de
MN
2605 for(;left>16+1+5+5; left-=8){
2606 if(show_bits(&s->gb, 16)==0){
2607 GetBitContext bak= s->gb;
92073d01 2608
4d2858de
MN
2609 if(s->codec_id==CODEC_ID_MPEG4)
2610 ret= mpeg4_decode_video_packet_header(s);
2611 else
2612 ret= h263_decode_gob_header(s);
2613 if(ret>=0)
2614 return 0;
92073d01 2615
4d2858de
MN
2616 s->gb= bak;
2617 }
2618 skip_bits(&s->gb, 8);
2619 }
2620
2621 return -1;
92073d01
MN
2622}
2623
2624/**
073b013d
MN
2625 * @param n either 0 for the x component or 1 for y
2626 * @returns the average MV for a GMC MB
2627 */
2628static inline int get_amv(MpegEncContext *s, int n){
2629 int x, y, mb_v, sum, dx, dy, shift;
2630 int len = 1 << (s->f_code + 4);
2631 const int a= s->sprite_warping_accuracy;
2632
2633 if(s->real_sprite_warping_points==1){
2634 if(s->divx_version==500 && s->divx_build==413)
2635 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2636 else
2637 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
2638 }else{
2639 dx= s->sprite_delta[n][0];
2640 dy= s->sprite_delta[n][1];
2641 shift= s->sprite_shift[0];
2642 if(n) dy -= 1<<(shift + a + 1);
2643 else dx -= 1<<(shift + a + 1);
2644 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
2645
2646 sum=0;
2647 for(y=0; y<16; y++){
2648 int v;
2649
2650 v= mb_v + dy*y;
2651 //XXX FIXME optimize
2652 for(x=0; x<16; x++){
2653 sum+= v>>shift;
2654 v+= dx;
2655 }
2656 }
2657 sum /= 256;
2658 sum= RSHIFT(sum<<s->quarter_sample, a);
2659 }
2660
2661 if (sum < -len) sum= -len;
2662 else if (sum >= len) sum= len-1;
2663
2664 return sum;
2665}
2666
2667/**
4d2858de
MN
2668 * decodes first partition.
2669 * @return number of MBs decoded or <0 if an error occured
92073d01 2670 */
4d2858de 2671static int mpeg4_decode_partition_a(MpegEncContext *s){
92073d01 2672 int mb_num;
4d2858de 2673 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
92073d01
MN
2674
2675 /* decode first partition */
2676 mb_num=0;
49092244 2677 s->first_slice_line=1;
4d2858de
MN
2678 for(; s->mb_y<s->mb_height; s->mb_y++){
2679 ff_init_block_index(s);
2680 for(; s->mb_x<s->mb_width; s->mb_x++){
92073d01
MN
2681 const int xy= s->mb_x + s->mb_y*s->mb_width;
2682 int cbpc;
2683 int dir=0;
2684
2685 mb_num++;
4d2858de 2686 ff_update_block_index(s);
92073d01
MN
2687 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2688 s->first_slice_line=0;
2689
2690 if(s->mb_x==0) PRINT_MB_TYPE("\n");
2691
2692 if(s->pict_type==I_TYPE){
2693 int i;
2694
4d2858de
MN
2695 if(show_bits(&s->gb, 19)==DC_MARKER){
2696 return mb_num-1;
2697 }
2698
92073d01 2699 PRINT_MB_TYPE("I");
edcf9890 2700 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
92073d01 2701 if (cbpc < 0){
4d2858de 2702
92073d01 2703 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
4d2858de 2704 return -1;
92073d01
MN
2705 }
2706 s->cbp_table[xy]= cbpc & 3;
2707 s->mb_type[xy]= MB_TYPE_INTRA;
2708 s->mb_intra = 1;
2709
2710 if(cbpc & 4) {
5482970b 2711 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
92073d01 2712 }
1e491e29 2713 s->current_picture.qscale_table[xy]= s->qscale;
92073d01
MN
2714
2715 s->mbintra_table[xy]= 1;
2716 for(i=0; i<6; i++){
2717 int dc_pred_dir;
2718 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2719 if(dc < 0){
2720 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
4d2858de 2721 return -1;
92073d01
MN
2722 }
2723 dir<<=1;
2724 if(dc_pred_dir) dir|=1;
2725 }
2726 s->pred_dir_table[xy]= dir;
4d2858de
MN
2727
2728 s->error_status_table[xy]= AC_ERROR;
92073d01 2729 }else{ /* P/S_TYPE */
4d2858de 2730 int mx, my, pred_x, pred_y, bits;
92073d01
MN
2731 INT16 * const mot_val= s->motion_val[s->block_index[0]];
2732 const int stride= s->block_wrap[0]*2;
2733
4d2858de
MN
2734 bits= show_bits(&s->gb, 17);
2735 if(bits==MOTION_MARKER){
2736 return mb_num-1;
2737 }
2738 skip_bits1(&s->gb);
2739 if(bits&0x10000){
92073d01
MN
2740 /* skip mb */
2741 s->mb_type[xy]= MB_TYPE_SKIPED;
2742 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
92073d01 2743 PRINT_MB_TYPE("G");
073b013d
MN
2744 mx= get_amv(s, 0);
2745 my= get_amv(s, 1);
92073d01
MN
2746 }else{
2747 PRINT_MB_TYPE("S");
073b013d 2748 mx=my=0;
92073d01
MN
2749 }
2750 mot_val[0 ]= mot_val[2 ]=
2751 mot_val[0+stride]= mot_val[2+stride]= mx;
2752 mot_val[1 ]= mot_val[3 ]=
2753 mot_val[1+stride]= mot_val[3+stride]= my;
2754
2755 if(s->mbintra_table[xy])
2756 ff_clean_intra_table_entries(s);
2757
4d2858de 2758 s->error_status_table[xy]= AC_ERROR;
92073d01
MN
2759 continue;
2760 }
edcf9890 2761 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
92073d01
MN
2762 if (cbpc < 0){
2763 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
4d2858de 2764 return -1;
92073d01
MN
2765 }
2766 if (cbpc > 20)
2767 cbpc+=3;
2768 else if (cbpc == 20)
2769 fprintf(stderr, "Stuffing !");
2770 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2771
2772 s->mb_intra = ((cbpc & 4) != 0);
2773
2774 if(s->mb_intra){
2775 PRINT_MB_TYPE("I");
2776 s->mbintra_table[xy]= 1;
2777 s->mb_type[xy]= MB_TYPE_INTRA;
2778 mot_val[0 ]= mot_val[2 ]=
2779 mot_val[0+stride]= mot_val[2+stride]= 0;
2780 mot_val[1 ]= mot_val[3 ]=
2781 mot_val[1+stride]= mot_val[3+stride]= 0;
4d2858de 2782 s->error_status_table[xy]= DC_ERROR|AC_ERROR;
92073d01
MN
2783 }else{
2784 if(s->mbintra_table[xy])
2785 ff_clean_intra_table_entries(s);
2786
2787 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2788 s->mcsel= get_bits1(&s->gb);
2789 else s->mcsel= 0;
2790
2791 if ((cbpc & 16) == 0) {
2792 PRINT_MB_TYPE("P");
2793 /* 16x16 motion prediction */
2794 s->mb_type[xy]= MB_TYPE_INTER;
2795
2796 h263_pred_motion(s, 0, &pred_x, &pred_y);
073b013d
MN
2797 if(!s->mcsel){
2798 mx = h263_decode_motion(s, pred_x, s->f_code);
2799 if (mx >= 0xffff)
2800 return -1;
2801
2802 my = h263_decode_motion(s, pred_y, s->f_code);
2803 if (my >= 0xffff)
2804 return -1;
2805 } else {
2806 mx = get_amv(s, 0);
2807 my = get_amv(s, 1);
92073d01 2808 }
073b013d 2809
92073d01
MN
2810 mot_val[0 ]= mot_val[2 ] =
2811 mot_val[0+stride]= mot_val[2+stride]= mx;
2812 mot_val[1 ]= mot_val[3 ]=
2813 mot_val[1+stride]= mot_val[3+stride]= my;
2814 } else {
2815 int i;
2816 PRINT_MB_TYPE("4");
2817 s->mb_type[xy]= MB_TYPE_INTER4V;
2818 for(i=0;i<4;i++) {
2819 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2820 mx = h263_decode_motion(s, pred_x, s->f_code);
2821 if (mx >= 0xffff)
4d2858de 2822 return -1;
92073d01
MN
2823
2824 my = h263_decode_motion(s, pred_y, s->f_code);
2825 if (my >= 0xffff)
4d2858de 2826 return -1;
92073d01
MN
2827 mot_val[0] = mx;
2828 mot_val[1] = my;
2829 }
2830 }
4d2858de 2831 s->error_status_table[xy]= AC_ERROR;
92073d01
MN
2832 }
2833 }
2834 }
2835 s->mb_x= 0;
2836 }
2837
4d2858de
MN
2838 return mb_num;
2839}
2840
2841/**
2842 * decode second partition.
2843 * @return <0 if an error occured
2844 */
2845static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
2846 int mb_num=0;
2847 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
92073d01 2848
92073d01 2849 s->mb_x= s->resync_mb_x;
4d2858de
MN
2850 s->first_slice_line=1;
2851 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
2852 ff_init_block_index(s);
2853 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
92073d01
MN
2854 const int xy= s->mb_x + s->mb_y*s->mb_width;
2855
2856 mb_num++;
4d2858de
MN
2857 ff_update_block_index(s);
2858 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2859 s->first_slice_line=0;
92073d01
MN
2860
2861 if(s->pict_type==I_TYPE){
2862 int ac_pred= get_bits1(&s->gb);
edcf9890 2863 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
92073d01
MN
2864 if(cbpy<0){
2865 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
4d2858de 2866 return -1;
92073d01
MN
2867 }
2868
2869 s->cbp_table[xy]|= cbpy<<2;
2870 s->pred_dir_table[xy]|= ac_pred<<7;
2871 }else{ /* P || S_TYPE */
2872 if(s->mb_type[xy]&MB_TYPE_INTRA){
2873 int dir=0,i;
2874 int ac_pred = get_bits1(&s->gb);
edcf9890 2875 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
92073d01
MN
2876
2877 if(cbpy<0){
2878 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
4d2858de 2879 return -1;
92073d01
MN
2880 }
2881
2882 if(s->cbp_table[xy] & 8) {
5482970b 2883 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
92073d01 2884 }
1e491e29 2885 s->current_picture.qscale_table[xy]= s->qscale;
92073d01
MN
2886
2887 for(i=0; i<6; i++){
2888 int dc_pred_dir;
2889 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2890 if(dc < 0){
2891 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
4d2858de 2892 return -1;
92073d01
MN
2893 }
2894 dir<<=1;
2895 if(dc_pred_dir) dir|=1;
2896 }
2897 s->cbp_table[xy]&= 3; //remove dquant
2898 s->cbp_table[xy]|= cbpy<<2;
2899 s->pred_dir_table[xy]= dir | (ac_pred<<7);
4d2858de 2900 s->error_status_table[xy]&= ~DC_ERROR;
92073d01 2901 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
1e491e29 2902 s->current_picture.qscale_table[xy]= s->qscale;
92073d01
MN
2903 s->cbp_table[xy]= 0;
2904 }else{
edcf9890 2905 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
92073d01
MN
2906
2907 if(cbpy<0){
2908 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
4d2858de 2909 return -1;
92073d01
MN
2910 }
2911
2912 if(s->cbp_table[xy] & 8) {
5482970b 2913 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
92073d01 2914 }
1e491e29 2915 s->current_picture.qscale_table[xy]= s->qscale;
92073d01
MN
2916
2917 s->cbp_table[xy]&= 3; //remove dquant
2918 s->cbp_table[xy]|= (cbpy^0xf)<<2;
2919 }
2920 }
2921 }
4d2858de 2922 if(mb_num >= mb_count) return 0;
92073d01
MN
2923 s->mb_x= 0;
2924 }
4d2858de
MN
2925 return 0;
2926}
2927
2928/**
2929 * decodes the first & second partition
2930 * @return <0 if error (and sets error type in the error_status_table)
2931 */
2932int ff_mpeg4_decode_partitions(MpegEncContext *s)
2933{
2934 int mb_num;
2935
2936 mb_num= mpeg4_decode_partition_a(s);
2937 if(mb_num<0)
2938 return -1;
2939
2940 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
2941 fprintf(stderr, "slice below monitor ...\n");
2942 return -1;
2943 }
2944
2945 s->mb_num_left= mb_num;
2946
2947 if(s->pict_type==I_TYPE){
2948 if(get_bits(&s->gb, 19)!=DC_MARKER){
2949 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
2950 return -1;
2951 }else
2952 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END;
2953 }else{
2954 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
2955 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
2956 return -1;
2957 }else
2958 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END;
2959 }
2960
2961 if( mpeg4_decode_partition_b(s, mb_num) < 0){
2962 return -1;
2963 }
92073d01 2964
4d2858de 2965 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END;
92073d01
MN
2966
2967 return 0;
2968}
2969
4d2858de
MN
2970/**
2971 * decode partition C of one MB.
2972 * @return <0 if an error occured
2973 */
2974static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
92073d01
MN
2975{
2976 int cbp, mb_type;
2977 const int xy= s->mb_x + s->mb_y*s->mb_width;
2978
92073d01 2979 mb_type= s->mb_type[xy];
4d2858de 2980 cbp = s->cbp_table[xy];
92073d01 2981
1e491e29
MN
2982 if(s->current_picture.qscale_table[xy] != s->qscale){
2983 s->qscale= s->current_picture.qscale_table[xy];
5482970b
MN
2984 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2985 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
92073d01 2986 }
4d2858de 2987
92073d01
MN
2988 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2989 int i;
2990 for(i=0; i<4; i++){
2991 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2992 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2993 }
2994 s->mb_intra = mb_type&MB_TYPE_INTRA;
2995
2996 if (mb_type&MB_TYPE_SKIPED) {
2997 /* skip mb */
2998 for(i=0;i<6;i++)
2999 s->block_last_index[i] = -1;
3000 s->mv_dir = MV_DIR_FORWARD;
3001 s->mv_type = MV_TYPE_16X16;
3002 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3003 s->mcsel=1;
3004 s->mb_skiped = 0;
3005 }else{
3006 s->mcsel=0;
3007 s->mb_skiped = 1;
3008 }
4d2858de 3009 }else if(s->mb_intra){
92073d01
MN
3010 s->ac_pred = s->pred_dir_table[xy]>>7;
3011
3012 /* decode each block */
3013 for (i = 0; i < 6; i++) {
4d2858de
MN
3014 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
3015 fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y);
3016 return -1;
92073d01 3017 }
3a3d3a42 3018 cbp+=cbp;
92073d01
MN
3019 }
3020 }else if(!s->mb_intra){
3021// s->mcsel= 0; //FIXME do we need to init that
3022
3023 s->mv_dir = MV_DIR_FORWARD;
3024 if (mb_type&MB_TYPE_INTER4V) {
3025 s->mv_type = MV_TYPE_8X8;
3026 } else {
3027 s->mv_type = MV_TYPE_16X16;
3028 }
4d2858de
MN
3029 /* decode each block */
3030 for (i = 0; i < 6; i++) {
3031 if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){
3032 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
3033 return -1;
92073d01 3034 }
4d2858de 3035 cbp+=cbp;
92073d01
MN
3036 }
3037 }
3038 } else { /* I-Frame */
3039 int i;
3040 s->mb_intra = 1;
3041 s->ac_pred = s->pred_dir_table[xy]>>7;
3042
3043 /* decode each block */
3044 for (i = 0; i < 6; i++) {
4d2858de 3045 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
92073d01 3046 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
92073d01
MN
3047 return -1;
3048 }
3a3d3a42 3049 cbp+=cbp;
92073d01
MN
3050 }
3051 }
49092244 3052
4d2858de 3053 s->error_status_table[xy]&= ~AC_ERROR;
49092244 3054
4d2858de 3055 /* per-MB end of slice check */
fd7db0fd 3056
4d2858de
MN
3057 if(--s->mb_num_left <= 0){
3058//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size*8 - get_bits_count(&s->gb));
3059 if(mpeg4_is_resync(s))
3060 return SLICE_END;
3061 else
3062 return SLICE_NOEND;
3063 }else{
3064 if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
3065 return SLICE_END;
3066 else
3067 return SLICE_OK;
fd7db0fd
MN
3068 }
3069}
92073d01 3070
4d2858de
MN
3071int ff_h263_decode_mb(MpegEncContext *s,
3072 DCTELEM block[6][64])
644d98a4
J
3073{
3074 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3075 INT16 *mot_val;
3076 static INT8 quant_tab[4] = { -1, -2, 1, 2 };
49c9325f 3077
4d2858de 3078 s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
32cd20de 3079
4d2858de 3080 if(s->mb_x==0) PRINT_MB_TYPE("\n");
92073d01 3081
73c8e514 3082 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
612476ef 3083 if (get_bits1(&s->gb)) {
de6d9b64
FB
3084 /* skip mb */
3085 s->mb_intra = 0;
3086 for(i=0;i<6;i++)
3087 s->block_last_index[i] = -1;
3088 s->mv_dir = MV_DIR_FORWARD;
3089 s->mv_type = MV_TYPE_16X16;
44eb4951 3090 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
32cd20de 3091 PRINT_MB_TYPE("G");
44eb4951 3092 s->mcsel=1;
073b013d
MN
3093 s->mv[0][0][0]= get_amv(s, 0);
3094 s->mv[0][0][1]= get_amv(s, 1);
44eb4951
MN
3095
3096 s->mb_skiped = 0;
3097 }else{
32cd20de 3098 PRINT_MB_TYPE("S");
44eb4951
MN
3099 s->mcsel=0;
3100 s->mv[0][0][0] = 0;
3101 s->mv[0][0][1] = 0;
3102 s->mb_skiped = 1;
3103 }
4d2858de 3104 goto end;
de6d9b64 3105 }
edcf9890 3106 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4949028f 3107 //fprintf(stderr, "\tCBPC: %d", cbpc);
de6d9b64
FB
3108 if (cbpc < 0)
3109 return -1;
96815ce9
J
3110 if (cbpc > 20)
3111 cbpc+=3;
3112 else if (cbpc == 20)
3113 fprintf(stderr, "Stuffing !");
4949028f 3114
de6d9b64
FB
3115 dquant = cbpc & 8;
3116 s->mb_intra = ((cbpc & 4) != 0);
6f91bcd1
MN
3117 if (s->mb_intra) goto intra;
3118
73c8e514
MN
3119 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3120 s->mcsel= get_bits1(&s->gb);
3121 else s->mcsel= 0;
edcf9890 3122 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
de6d9b64
FB
3123 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
3124 if (dquant) {
5482970b 3125 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
de6d9b64 3126 }
4d2858de 3127 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
fd7db0fd
MN
3128 s->interlaced_dct= get_bits1(&s->gb);
3129
de6d9b64
FB
3130 s->mv_dir = MV_DIR_FORWARD;
3131 if ((cbpc & 16) == 0) {
fd7db0fd 3132 if(s->mcsel){
fd7db0fd
MN
3133 PRINT_MB_TYPE("G");
3134 /* 16x16 global motion prediction */
3135 s->mv_type = MV_TYPE_16X16;
073b013d
MN
3136 mx= get_amv(s, 0);
3137 my= get_amv(s, 1);
fd7db0fd
MN
3138 s->mv[0][0][0] = mx;
3139 s->mv[0][0][1] = my;
3140 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3141 PRINT_MB_TYPE("f");
3142 /* 16x8 field motion prediction */
3143 s->mv_type= MV_TYPE_FIELD;
3144
3145 s->field_select[0][0]= get_bits1(&s->gb);
3146 s->field_select[0][1]= get_bits1(&s->gb);
3147
3148 h263_pred_motion(s, 0, &pred_x, &pred_y);
3149
3150 for(i=0; i<2; i++){
3151 mx = h263_decode_motion(s, pred_x, s->f_code);
3152 if (mx >= 0xffff)
3153 return -1;
3154
3155 my = h263_decode_motion(s, pred_y/2, s->f_code);
3156 if (my >= 0xffff)
3157 return -1;
3158
3159 s->mv[0][i][0] = mx;
b9d2bb5b 3160 s->mv[0][i][1] = my;
14ae07d8 3161 }
fd7db0fd
MN
3162 }else{
3163 PRINT_MB_TYPE("P");
3164 /* 16x16 motion prediction */
3165 s->mv_type = MV_TYPE_16X16;
3166 h263_pred_motion(s, 0, &pred_x, &pred_y);
3167 if (s->umvplus_dec)
3168 mx = h263p_decode_umotion(s, pred_x);
3169 else
3170 mx = h263_decode_motion(s, pred_x, s->f_code);
3171
3172 if (mx >= 0xffff)
3173 return -1;
3174
3175 if (s->umvplus_dec)
3176 my = h263p_decode_umotion(s, pred_y);
3177 else
3178 my = h263_decode_motion(s, pred_y, s->f_code);
3179
3180 if (my >= 0xffff)
3181 return -1;
3182 s->mv[0][0][0] = mx;
3183 s->mv[0][0][1] = my;
3184
3185 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
3186 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
44eb4951 3187 }
de6d9b64 3188 } else {
32cd20de 3189 PRINT_MB_TYPE("4");
de6d9b64
FB
3190 s->mv_type = MV_TYPE_8X8;
3191 for(i=0;i<4;i++) {
3192 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
544286b3 3193 if (s->umvplus_dec)
6dbd39fe
J
3194 mx = h263p_decode_umotion(s, pred_x);
3195 else
6f91bcd1 3196 mx = h263_decode_motion(s, pred_x, s->f_code);
de6d9b64
FB
3197 if (mx >= 0xffff)
3198 return -1;
6dbd39fe 3199
544286b3 3200 if (s->umvplus_dec)
6dbd39fe
J
3201 my = h263p_decode_umotion(s, pred_y);
3202 else
6f91bcd1 3203 my = h263_decode_motion(s, pred_y, s->f_code);
de6d9b64
FB
3204 if (my >= 0xffff)
3205 return -1;
3206 s->mv[0][i][0] = mx;
3207 s->mv[0][i][1] = my;
544286b3 3208 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
6dbd39fe 3209 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
de6d9b64
FB
3210 mot_val[0] = mx;
3211 mot_val[1] = my;
3212 }
3213 }
6f91bcd1
MN
3214 } else if(s->pict_type==B_TYPE) {
3215 int modb1; // first bit of modb
3216 int modb2; // second bit of modb
3217 int mb_type;
6f91bcd1
MN
3218 int xy;
3219
3220 s->mb_intra = 0; //B-frames never contain intra blocks
3221 s->mcsel=0; // ... true gmc blocks
3222
3223 if(s->mb_x==0){
a172cae6
MN
3224 for(i=0; i<2; i++){
3225 s->last_mv[i][0][0]=
3226 s->last_mv[i][0][1]=
3227 s->last_mv[i][1][0]=
3228 s->last_mv[i][1][1]= 0;
3229 }
6f91bcd1
MN
3230 }
3231
3232 /* if we skipped it in the future P Frame than skip it now too */
1e491e29 3233 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
6f91bcd1
MN
3234
3235 if(s->mb_skiped){
3236 /* skip mb */
3237 for(i=0;i<6;i++)
3238 s->block_last_index[i] = -1;
3239
3240 s->mv_dir = MV_DIR_FORWARD;
3241 s->mv_type = MV_TYPE_16X16;
3242 s->mv[0][0][0] = 0;
3243 s->mv[0][0][1] = 0;
3244 s->mv[1][0][0] = 0;
3245 s->mv[1][0][1] = 0;
c60a6560 3246 PRINT_MB_TYPE("s");
4d2858de 3247 goto end;
6f91bcd1
MN
3248 }
3249
fc97db64
MN
3250 modb1= get_bits1(&s->gb);
3251 if(modb1){
3252 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
3253 cbp=0;
3254 }else{
3255 int field_mv;
3256
6f91bcd1 3257 modb2= get_bits1(&s->gb);
edcf9890 3258 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
fc97db64
MN
3259 if(modb2) cbp= 0;
3260 else cbp= get_bits(&s->gb, 6);
3261
3262 if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
6f91bcd1 3263 if(get_bits1(&s->gb)){
5482970b 3264 change_qscale(s, get_bits1(&s->gb)*4 - 2);
6f91bcd1
MN
3265 }
3266 }
fc97db64 3267 field_mv=0;
bea669e5
MN
3268
3269 if(!s->progressive_sequence){
3270 if(cbp)
3271 s->interlaced_dct= get_bits1(&s->gb);
3272
e3bd83f8 3273 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
fc97db64 3274 field_mv=1;
e3bd83f8
MN
3275
3276 if(mb_type!=MB_TYPE_B_BACKW){
3277 s->field_select[0][0]= get_bits1(&s->gb);
3278 s->field_select[0][1]= get_bits1(&s->gb);
3279 }
3280 if(mb_type!=MB_TYPE_B_FORW){
3281 s->field_select[1][0]= get_bits1(&s->gb);
3282 s->field_select[1][1]= get_bits1(&s->gb);
3283 }
3284 }
bea669e5 3285 }
bea669e5 3286
e3bd83f8 3287 s->mv_dir = 0;
fc97db64
MN
3288 if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
3289 s->mv_type= MV_TYPE_16X16;
3290 if(mb_type!=MB_TYPE_B_BACKW){
3291 s->mv_dir = MV_DIR_FORWARD;
3292
3293 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
3294 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
3295 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3296 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
e3bd83f8 3297 }
fc97db64
MN
3298
3299 if(mb_type!=MB_TYPE_B_FORW){
3300 s->mv_dir |= MV_DIR_BACKWARD;
3301
3302 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
3303 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
3304 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
3305 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
3306 }
3307 if(mb_type!=MB_TYPE_B_DIRECT)
3308 PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
3309 }else if(mb_type!=MB_TYPE_B_DIRECT){
3310 s->mv_type= MV_TYPE_FIELD;
e3bd83f8 3311
fc97db64
MN
3312 if(mb_type!=MB_TYPE_B_BACKW){
3313 s->mv_dir = MV_DIR_FORWARD;
fc97db64
MN
3314
3315 for(i=0; i<2; i++){
3316 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
3317 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3318 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
3319 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3320 }
e3bd83f8 3321 }
fc97db64
MN
3322
3323 if(mb_type!=MB_TYPE_B_FORW){
3324 s->mv_dir |= MV_DIR_BACKWARD;
fc97db64
MN
3325
3326 for(i=0; i<2; i++){
3327 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
3328 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
3329 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
3330 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
3331 }
bea669e5 3332 }
fc97db64
MN
3333 if(mb_type!=MB_TYPE_B_DIRECT)
3334 PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
bea669e5 3335 }
bea669e5 3336 }
fc97db64 3337
bea669e5 3338 if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
fc97db64
MN
3339 if(mb_type==4)
3340 mx=my=0;
3341 else{
3342 mx = h263_decode_motion(s, 0, 1);
3343 my = h263_decode_motion(s, 0, 1);
3344 }
bea669e5 3345
6f91bcd1 3346 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1457ab52 3347 ff_mpeg4_set_direct_mv(s, mx, my);
bea669e5
MN
3348 }
3349
3350 if(mb_type<0 || mb_type>4){
e71a4f74
MN
3351 printf("illegal MB_type\n");
3352 return -1;
6f91bcd1
MN
3353 }
3354 } else { /* I-Frame */
edcf9890 3355 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
6f91bcd1
MN
3356 if (cbpc < 0)
3357 return -1;
3358 dquant = cbpc & 4;
3359 s->mb_intra = 1;
3360intra:
de6d9b64 3361 s->ac_pred = 0;
d140623f 3362 if (s->h263_pred || s->h263_aic) {
612476ef 3363 s->ac_pred = get_bits1(&s->gb);
d140623f
J
3364 if (s->ac_pred && s->h263_aic)
3365 s->h263_aic_dir = get_bits1(&s->gb);
de6d9b64 3366 }
d930ef19
MN
3367 PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
3368
edcf9890 3369 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
92073d01 3370 if(cbpy<0) return -1;
de6d9b64
FB
3371 cbp = (cbpc & 3) | (cbpy << 2);
3372 if (dquant) {
5482970b 3373 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
de6d9b64 3374 }
4d2858de 3375
fd7db0fd
MN
3376 if(!s->progressive_sequence)
3377 s->interlaced_dct= get_bits1(&s->gb);
3e6a20a0
MN
3378
3379 /* decode each block */
3380 if (s->h263_pred) {
3381 for (i = 0; i < 6; i++) {
3a3d3a42 3382 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
3e6a20a0 3383 return -1;
3a3d3a42 3384 cbp+=cbp;
3e6a20a0
MN
3385 }
3386 } else {
3387 for (i = 0; i < 6; i++) {
3a3d3a42 3388 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3e6a20a0 3389 return -1;
3a3d3a42 3390 cbp+=cbp;
3e6a20a0
MN
3391 }
3392 }
4d2858de 3393 goto end;
de6d9b64
FB
3394 }
3395
3396 /* decode each block */
3397 if (s->h263_pred) {
3e6a20a0 3398 for (i = 0; i < 6; i++) {
3a3d3a42 3399 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
de6d9b64 3400 return -1;
3a3d3a42 3401 cbp+=cbp;
3e6a20a0 3402 }
de6d9b64 3403 } else {
3e6a20a0 3404 for (i = 0; i < 6; i++) {
3a3d3a42 3405 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
de6d9b64 3406 return -1;
3a3d3a42 3407 cbp+=cbp;
3e6a20a0 3408 }
de6d9b64 3409 }
4d2858de
MN
3410end:
3411
3412 /* per-MB end of slice check */
3413 if(s->codec_id==CODEC_ID_MPEG4){
3414 if(mpeg4_is_resync(s)){
1e491e29 3415 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
4d2858de
MN
3416 return SLICE_OK;
3417 return SLICE_END;
3418 }
3419 }else{
e4828c7d
MN
3420 int v= show_bits(&s->gb, 16);
3421
3422 if(get_bits_count(&s->gb) + 16 > s->gb.size*8){
3423 v>>= get_bits_count(&s->gb) + 16 - s->gb.size*8;
4d2858de 3424