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