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