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