« back to all changes in this revision
Viewing changes to ffmpeg/libavcodec/h263.c
- browse files at revision 5
- compare with another revision
- download diff
- download tarball
- view history from revision 5
- Committer: Bazaar Package Importer
- Author(s): John Dong
- Date: 2008-02-25 15:47:12 UTC
- mfrom: (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20080225154712-qvr11ekcea4c9ry8
Tags: 1.1.6-0.1ubuntu1
* Merge from debian-multimedia (LP: #120003), Ubuntu Changes:
- For ffmpeg-related build-deps, remove cvs from package names.
- Standards-Version 3.7.3
- Maintainer Spec
- For ffmpeg-related build-deps, remove cvs from package names.
- Standards-Version 3.7.3
- Maintainer Spec
- files added:
- TODO.tasks
- doc
- doc/man
- doc/man/C
- doc/man/de
- doc/man/es
- doc/man/it
- doc/xvidcap
- doc/xvidcap/C
- doc/xvidcap/C/figures
- doc/xvidcap/de
- doc/xvidcap/de/figures
- doc/xvidcap/es
- doc/xvidcap/es/figures
- doc/xvidcap/it
- doc/xvidcap/it/figures
- ffmpeg/libavcodec/bfin
- ffmpeg/libavcodec/sparc
- ffmpeg/libavutil
- ffmpeg/libpostproc
- ffmpeg/libswscale
- po
- src/pixmaps
- files removed:
- TODO
- Xw
- ffmpeg/libavcodec/liba52
- ffmpeg/libavcodec/libpostproc
- getopt
- gt
- man
- xbm
- files modified:
- AUTHORS
added
removed
ffmpeg/libavcodec/h263.c
3
3
* Copyright (c) 2000,2001 Fabrice Bellard.
4
4
* H263+ support.
5
5
* Copyright (c) 2001 Juan J. Sierralta P.
6
*
7
* This library is free software; you can redistribute it and/or
6
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
7
*
8
* This file is part of FFmpeg.
9
*
10
* FFmpeg is free software; you can redistribute it and/or
8
11
* modify it under the terms of the GNU Lesser General Public
9
12
* License as published by the Free Software Foundation; either
10
* version 2 of the License, or (at your option) any later version.
13
* version 2.1 of the License, or (at your option) any later version.
11
14
*
12
* This library is distributed in the hope that it will be useful,
15
* FFmpeg is distributed in the hope that it will be useful,
13
16
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
18
* Lesser General Public License for more details.
16
19
*
17
20
* You should have received a copy of the GNU Lesser General Public
18
* License along with this library; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
* License along with FFmpeg; if not, write to the Free Software
22
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
23
*
21
24
* ac prediction encoding, b-frame support, error resilience, optimizations,
22
* qpel decoding, gmc decoding, interlaced decoding,
25
* qpel decoding, gmc decoding, interlaced decoding,
23
26
* by Michael Niedermayer <michaelni@gmx.at>
24
27
*/
25
28
27
30
* @file h263.c
28
31
* h263/mpeg4 codec.
29
32
*/
30
33
31
34
//#define DEBUG
35
#include <limits.h>
36
32
37
#include "common.h"
33
38
#include "dsputil.h"
34
39
#include "avcodec.h"
47
52
#define SPRITE_TRAJ_VLC_BITS 6
48
53
#define MB_TYPE_B_VLC_BITS 4
49
54
#define TEX_VLC_BITS 9
55
#define H263_MBTYPE_B_VLC_BITS 6
56
#define CBPC_B_VLC_BITS 3
50
57
51
58
#ifdef CONFIG_ENCODERS
52
59
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
53
60
int n);
54
static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
55
61
static void h263p_encode_umotion(MpegEncContext * s, int val);
56
62
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
57
int n, int dc, uint8_t *scan_table,
63
int n, int dc, uint8_t *scan_table,
58
64
PutBitContext *dc_pb, PutBitContext *ac_pb);
65
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
66
uint8_t *scan_table);
59
67
#endif
60
68
61
69
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
65
73
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
66
74
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
67
75
int n, int coded, int intra, int rvlc);
68
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
69
76
#ifdef CONFIG_ENCODERS
70
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
71
int dir);
77
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
72
78
static void mpeg4_encode_visual_object_header(MpegEncContext * s);
73
79
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
74
80
#endif //CONFIG_ENCODERS
75
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
76
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
81
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
82
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
77
83
78
84
#ifdef CONFIG_ENCODERS
79
85
static uint8_t uni_DCtab_lum_len[512];
89
95
static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
90
96
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
91
97
static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
98
static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
99
static uint8_t uni_h263_inter_rl_len [64*64*2*2];
92
100
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
93
101
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
94
102
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
104
112
*/
105
113
#endif
106
114
107
#if 0 //3IV1 is quite rare and tis slows things down a tiny bit
108
#define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
109
#else
115
#if 0 //3IV1 is quite rare and it slows things down a tiny bit
116
#define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
117
#else
110
118
#define IS_3IV1 0
111
119
#endif
112
120
131
139
132
140
#ifdef CONFIG_ENCODERS
133
141
134
static void float_aspect_to_info(MpegEncContext * s, float aspect){
142
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
135
143
int i;
136
144
137
aspect*= s->height/(double)s->width;
138
//printf("%f\n", aspect);
139
140
if(aspect==0) aspect= 1.0;
141
142
ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
143
144
//printf("%d %d\n", s->aspected_width, s->aspected_height);
145
if(aspect.num==0) aspect= (AVRational){1,1};
146
145
147
for(i=1; i<6; i++){
146
if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
148
if(av_cmp_q(pixel_aspect[i], aspect) == 0){
147
149
s->aspect_ratio_info=i;
148
150
return;
149
151
}
150
152
}
151
153
152
154
s->aspect_ratio_info= FF_ASPECT_EXTENDED;
153
155
}
154
156
160
162
161
163
put_bits(&s->pb, 17, 1);
162
164
put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
163
put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
164
s->avctx->frame_rate) & 0xff); /* TemporalReference */
165
put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
166
s->avctx->time_base.den) & 0xff); /* TemporalReference */
165
167
if (s->width == 352 && s->height == 288)
166
168
format = 2;
167
169
else if (s->width == 176 && s->height == 144)
190
192
put_bits(&s->pb, 1, 0); /* ExtraInformation */
191
193
192
194
if(s->h263_aic){
193
s->y_dc_scale_table=
194
s->c_dc_scale_table= h263_aic_dc_scale_table;
195
s->y_dc_scale_table=
196
s->c_dc_scale_table= ff_aic_dc_scale_table;
195
197
}else{
196
198
s->y_dc_scale_table=
197
199
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
200
202
201
203
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
202
204
{
203
int format;
205
int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
206
int best_clock_code=1;
207
int best_divisor=60;
208
int best_error= INT_MAX;
209
210
if(s->h263_plus){
211
for(i=0; i<2; i++){
212
int div, error;
213
div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
214
div= av_clip(1, div, 127);
215
error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
216
if(error < best_error){
217
best_error= error;
218
best_divisor= div;
219
best_clock_code= i;
220
}
221
}
222
}
223
s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
224
coded_frame_rate= 1800000;
225
coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
204
226
205
227
align_put_bits(&s->pb);
206
228
207
229
/* Update the pointer to last GOB */
208
230
s->ptr_lastgob = pbBufPtr(&s->pb);
209
s->gob_number = 0;
210
211
231
put_bits(&s->pb, 22, 0x20); /* PSC */
212
put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
213
s->avctx->frame_rate) & 0xff);
214
215
put_bits(&s->pb, 1, 1); /* marker */
216
put_bits(&s->pb, 1, 0); /* h263 id */
217
put_bits(&s->pb, 1, 0); /* split screen off */
218
put_bits(&s->pb, 1, 0); /* camera off */
219
put_bits(&s->pb, 1, 0); /* freeze picture release off */
220
232
temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
233
(coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
234
put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
235
236
put_bits(&s->pb, 1, 1); /* marker */
237
put_bits(&s->pb, 1, 0); /* h263 id */
238
put_bits(&s->pb, 1, 0); /* split screen off */
239
put_bits(&s->pb, 1, 0); /* camera off */
240
put_bits(&s->pb, 1, 0); /* freeze picture release off */
241
221
242
format = h263_get_picture_format(s->width, s->height);
222
243
if (!s->h263_plus) {
223
244
/* H.263v1 */
226
247
/* By now UMV IS DISABLED ON H.263v1, since the restrictions
227
248
of H.263v1 UMV implies to check the predicted MV after
228
249
calculation of the current MB to see if we're on the limits */
229
put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
230
put_bits(&s->pb, 1, 0); /* SAC: off */
231
put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
232
put_bits(&s->pb, 1, 0); /* not PB frame */
250
put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
251
put_bits(&s->pb, 1, 0); /* SAC: off */
252
put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
253
put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
233
254
put_bits(&s->pb, 5, s->qscale);
234
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
255
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
235
256
} else {
257
int ufep=1;
236
258
/* H.263v2 */
237
259
/* H.263 Plus PTYPE */
260
238
261
put_bits(&s->pb, 3, 7);
239
put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
262
put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
240
263
if (format == 7)
241
264
put_bits(&s->pb,3,6); /* Custom Source Format */
242
265
else
243
266
put_bits(&s->pb, 3, format);
244
245
put_bits(&s->pb,1,0); /* Custom PCF: off */
246
s->umvplus = s->unrestricted_mv;
247
put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
267
268
put_bits(&s->pb,1, s->custom_pcf);
269
put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
248
270
put_bits(&s->pb,1,0); /* SAC: off */
249
put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
271
put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
250
272
put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
251
put_bits(&s->pb,1,0); /* Deblocking Filter: off */
252
put_bits(&s->pb,1,0); /* Slice Structured: off */
273
put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
274
put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
253
275
put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
254
276
put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
255
put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
256
put_bits(&s->pb,1,0); /* Modified Quantization: off */
277
put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
278
put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
257
279
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
258
280
put_bits(&s->pb,3,0); /* Reserved */
259
281
260
282
put_bits(&s->pb, 3, s->pict_type == P_TYPE);
261
283
262
284
put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
263
285
put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
264
286
put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
265
287
put_bits(&s->pb,2,0); /* Reserved */
266
288
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
267
289
268
290
/* This should be here if PLUSPTYPE */
269
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
270
271
if (format == 7) {
291
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
292
293
if (format == 7) {
272
294
/* Custom Picture Format (CPFMT) */
273
float_aspect_to_info(s, s->avctx->aspect_ratio);
295
aspect_to_info(s, s->avctx->sample_aspect_ratio);
274
296
275
297
put_bits(&s->pb,4,s->aspect_ratio_info);
276
298
put_bits(&s->pb,9,(s->width >> 2) - 1);
277
299
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
278
300
put_bits(&s->pb,9,(s->height >> 2));
279
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
280
{
281
put_bits(&s->pb, 8, s->aspected_width);
282
put_bits(&s->pb, 8, s->aspected_height);
283
}
284
}
285
301
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
302
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
303
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
304
}
305
}
306
if(s->custom_pcf){
307
if(ufep){
308
put_bits(&s->pb, 1, best_clock_code);
309
put_bits(&s->pb, 7, best_divisor);
310
}
311
put_bits(&s->pb, 2, (temp_ref>>8)&3);
312
}
313
286
314
/* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
287
315
if (s->umvplus)
288
316
// put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
317
//FIXME check actual requested range
289
318
put_bits(&s->pb,2,1); /* unlimited */
319
if(s->h263_slice_structured)
320
put_bits(&s->pb,2,0); /* no weird submodes */
290
321
291
322
put_bits(&s->pb, 5, s->qscale);
292
323
}
293
324
294
put_bits(&s->pb, 1, 0); /* no PEI */
325
put_bits(&s->pb, 1, 0); /* no PEI */
326
327
if(s->h263_slice_structured){
328
put_bits(&s->pb, 1, 1);
329
330
assert(s->mb_x == 0 && s->mb_y == 0);
331
ff_h263_encode_mba(s);
332
333
put_bits(&s->pb, 1, 1);
334
}
295
335
296
336
if(s->h263_aic){
297
s->y_dc_scale_table=
298
s->c_dc_scale_table= h263_aic_dc_scale_table;
337
s->y_dc_scale_table=
338
s->c_dc_scale_table= ff_aic_dc_scale_table;
299
339
}else{
300
340
s->y_dc_scale_table=
301
341
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
305
345
/**
306
346
* Encodes a group of blocks header.
307
347
*/
308
int h263_encode_gob_header(MpegEncContext * s, int mb_line)
309
{
310
align_put_bits(&s->pb);
311
flush_put_bits(&s->pb);
312
/* Call the RTP callback to send the last GOB */
313
if (s->rtp_callback) {
314
int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
315
s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
316
}
317
put_bits(&s->pb, 17, 1); /* GBSC */
318
s->gob_number = mb_line / s->gob_index;
319
put_bits(&s->pb, 5, s->gob_number); /* GN */
320
put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
321
put_bits(&s->pb, 5, s->qscale); /* GQUANT */
322
//fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
323
return 0;
324
}
325
326
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
327
{
328
int score0=0, score1=0;
348
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
349
{
350
put_bits(&s->pb, 17, 1); /* GBSC */
351
352
if(s->h263_slice_structured){
353
put_bits(&s->pb, 1, 1);
354
355
ff_h263_encode_mba(s);
356
357
if(s->mb_num > 1583)
358
put_bits(&s->pb, 1, 1);
359
put_bits(&s->pb, 5, s->qscale); /* GQUANT */
360
put_bits(&s->pb, 1, 1);
361
put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
362
}else{
363
int gob_number= mb_line / s->gob_index;
364
365
put_bits(&s->pb, 5, gob_number); /* GN */
366
put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
367
put_bits(&s->pb, 5, s->qscale); /* GQUANT */
368
}
369
}
370
371
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
372
int last=0;
373
int j;
374
int rate=0;
375
376
for(j=1; j<=block_last_index; j++){
377
const int index= scantable[j];
378
int level= block[index];
379
if(level){
380
level+= 64;
381
if((level&(~127)) == 0){
382
if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
383
else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
384
}else
385
rate += s->ac_esc_length;
386
level-= 64;
387
388
last= j;
389
}
390
}
391
392
return rate;
393
}
394
395
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
396
{
397
int score= 0;
329
398
int i, n;
330
399
int8_t * const qscale_table= s->current_picture.qscale_table;
331
400
401
memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
402
332
403
for(n=0; n<6; n++){
333
404
int16_t *ac_val, *ac_val1;
334
405
406
score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
407
335
408
ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
336
409
ac_val1= ac_val;
337
410
if(dir[n]){
342
415
/* same qscale */
343
416
for(i=1; i<8; i++){
344
417
const int level= block[n][s->dsp.idct_permutation[i ]];
345
score0+= ABS(level);
346
score1+= ABS(level - ac_val[i+8]);
418
block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
347
419
ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
348
420
ac_val1[i+8]= level;
349
421
}
351
423
/* different qscale, we must rescale */
352
424
for(i=1; i<8; i++){
353
425
const int level= block[n][s->dsp.idct_permutation[i ]];
354
score0+= ABS(level);
355
score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
426
block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
356
427
ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
357
428
ac_val1[i+8]= level;
358
429
}
359
430
}
431
st[n]= s->intra_h_scantable.permutated;
360
432
}else{
361
433
const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
362
434
/* left prediction */
365
437
/* same qscale */
366
438
for(i=1; i<8; i++){
367
439
const int level= block[n][s->dsp.idct_permutation[i<<3]];
368
score0+= ABS(level);
369
score1+= ABS(level - ac_val[i]);
440
block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
370
441
ac_val1[i ]= level;
371
442
ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
372
443
}
374
445
/* different qscale, we must rescale */
375
446
for(i=1; i<8; i++){
376
447
const int level= block[n][s->dsp.idct_permutation[i<<3]];
377
score0+= ABS(level);
378
score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
448
block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
379
449
ac_val1[i ]= level;
380
450
ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
381
451
}
382
452
}
383
}
384
}
385
386
return score0 > score1 ? 1 : 0;
453
st[n]= s->intra_v_scantable.permutated;
454
}
455
456
for(i=63; i>0; i--) //FIXME optimize
457
if(block[n][ st[n][i] ]) break;
458
s->block_last_index[n]= i;
459
460
score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
461
}
462
463
return score < 0;
464
}
465
466
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
467
{
468
int i, n;
469
memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
470
471
for(n=0; n<6; n++){
472
int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
473
474
st[n]= s->intra_scantable.permutated;
475
if(dir[n]){
476
/* top prediction */
477
for(i=1; i<8; i++){
478
block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
479
}
480
}else{
481
/* left prediction */
482
for(i=1; i<8; i++){
483
block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
484
}
485
}
486
}
487
}
488
489
/**
490
* init s->current_picture.qscale_table from s->lambda_table
491
*/
492
static void ff_init_qscale_tab(MpegEncContext *s){
493
int8_t * const qscale_table= s->current_picture.qscale_table;
494
int i;
495
496
for(i=0; i<s->mb_num; i++){
497
unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
498
int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
499
qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
500
}
387
501
}
388
502
389
503
/**
392
506
void ff_clean_h263_qscales(MpegEncContext *s){
393
507
int i;
394
508
int8_t * const qscale_table= s->current_picture.qscale_table;
395
509
510
ff_init_qscale_tab(s);
511
396
512
for(i=1; i<s->mb_num; i++){
397
513
if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
398
514
qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
401
517
if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
402
518
qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
403
519
}
520
521
if(s->codec_id != CODEC_ID_H263P){
522
for(i=1; i<s->mb_num; i++){
523
int mb_xy= s->mb_index2xy[i];
524
525
if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
526
s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
527
}
528
}
529
}
404
530
}
405
531
406
532
/**
411
537
int8_t * const qscale_table= s->current_picture.qscale_table;
412
538
413
539
ff_clean_h263_qscales(s);
414
415
for(i=1; i<s->mb_num; i++){
416
int mb_xy= s->mb_index2xy[i];
417
418
if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){
419
s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;
420
s->mb_type[mb_xy]|= MB_TYPE_INTER;
421
}
422
}
423
540
424
541
if(s->pict_type== B_TYPE){
425
542
int odd=0;
426
/* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
427
for the actual adaptive quantization */
428
543
/* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
544
429
545
for(i=0; i<s->mb_num; i++){
430
546
int mb_xy= s->mb_index2xy[i];
431
547
odd += qscale_table[mb_xy]&1;
432
548
}
433
549
434
550
if(2*odd > s->mb_num) odd=1;
435
551
else odd=0;
436
552
437
553
for(i=0; i<s->mb_num; i++){
438
554
int mb_xy= s->mb_index2xy[i];
439
555
if((qscale_table[mb_xy]&1) != odd)
440
556
qscale_table[mb_xy]++;
441
557
if(qscale_table[mb_xy] > 31)
442
558
qscale_table[mb_xy]= 31;
443
}
444
559
}
560
445
561
for(i=1; i<s->mb_num; i++){
446
562
int mb_xy= s->mb_index2xy[i];
447
if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){
448
s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;
449
s->mb_type[mb_xy]|= MB_TYPE_BIDIR;
563
if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
564
s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
450
565
}
451
566
}
452
567
}
453
568
}
454
569
455
570
#endif //CONFIG_ENCODERS
571
572
#define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
573
#define tab_bias (tab_size/2)
574
575
void ff_mpeg4_init_direct_mv(MpegEncContext *s){
576
int i;
577
for(i=0; i<tab_size; i++){
578
s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
579
s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
580
}
581
}
582
583
static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
584
int xy= s->block_index[i];
585
uint16_t time_pp= s->pp_time;
586
uint16_t time_pb= s->pb_time;
587
int p_mx, p_my;
588
589
p_mx= s->next_picture.motion_val[0][xy][0];
590
if((unsigned)(p_mx + tab_bias) < tab_size){
591
s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
592
s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
593
: s->direct_scale_mv[1][p_mx + tab_bias];
594
}else{
595
s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
596
s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
597
: p_mx*(time_pb - time_pp)/time_pp;
598
}
599
p_my= s->next_picture.motion_val[0][xy][1];
600
if((unsigned)(p_my + tab_bias) < tab_size){
601
s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
602
s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
603
: s->direct_scale_mv[1][p_my + tab_bias];
604
}else{
605
s->mv[0][i][1] = p_my*time_pb/time_pp + my;
606
s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
607
: p_my*(time_pb - time_pp)/time_pp;
608
}
609
}
610
611
#undef tab_size
612
#undef tab_bias
613
456
614
/**
457
615
*
458
616
* @return the mb_type
459
617
*/
460
618
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
461
619
const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
462
const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?
463
int xy= s->block_index[0];
620
const int colocated_mb_type= s->next_picture.mb_type[mb_index];
464
621
uint16_t time_pp= s->pp_time;
465
622
uint16_t time_pb= s->pb_time;
466
623
int i;
467
624
468
625
//FIXME avoid divides
469
626
// try special case with shifts for 1 and 3 B-frames?
627
470
628
if(IS_8X8(colocated_mb_type)){
471
629
s->mv_type = MV_TYPE_8X8;
472
630
for(i=0; i<4; i++){
473
xy= s->block_index[i];
474
s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
475
s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
476
s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
477
: s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
478
s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
479
: s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
631
ff_mpeg4_set_one_direct_mv(s, mx, my, i);
480
632
}
481
633
return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
482
634
} else if(IS_INTERLACED(colocated_mb_type)){
483
635
s->mv_type = MV_TYPE_FIELD;
484
636
for(i=0; i<2; i++){
637
int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
638
s->field_select[0][i]= field_select;
639
s->field_select[1][i]= i;
485
640
if(s->top_field_first){
486
time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
487
time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
641
time_pp= s->pp_field_time - field_select + i;
642
time_pb= s->pb_field_time - field_select + i;
488
643
}else{
489
time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
490
time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
644
time_pp= s->pp_field_time + field_select - i;
645
time_pb= s->pb_field_time + field_select - i;
491
646
}
492
s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
493
s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
494
s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
495
: s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
496
s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
497
: s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
647
s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
648
s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
649
s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
650
: s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
651
s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
652
: s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
498
653
}
499
654
return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
500
655
}else{
501
s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
502
s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
503
s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
504
: s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
505
s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
506
: s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
656
ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
657
s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
658
s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
659
s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
660
s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
507
661
if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
508
662
s->mv_type= MV_TYPE_16X16;
509
663
else
514
668
515
669
void ff_h263_update_motion_val(MpegEncContext * s){
516
670
const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
517
//FIXME a lot of thet is only needed for !low_delay
518
const int wrap = s->block_wrap[0];
671
//FIXME a lot of that is only needed for !low_delay
672
const int wrap = s->b8_stride;
519
673
const int xy = s->block_index[0];
520
521
s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
674
675
s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
522
676
523
677
if(s->mv_type != MV_TYPE_8X8){
524
678
int motion_x, motion_y;
534
688
motion_y = s->mv[0][0][1] + s->mv[0][1][1];
535
689
motion_x = (motion_x>>1) | (motion_x&1);
536
690
for(i=0; i<2; i++){
537
s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
538
s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
539
s->field_select_table[mb_xy][i]= s->field_select[0][i];
691
s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
692
s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
540
693
}
694
s->current_picture.ref_index[0][xy ]=
695
s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
696
s->current_picture.ref_index[0][xy + wrap ]=
697
s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
541
698
}
542
699
543
700
/* no update if 8X8 because it has been done during parsing */
544
s->motion_val[xy][0] = motion_x;
545
s->motion_val[xy][1] = motion_y;
546
s->motion_val[xy + 1][0] = motion_x;
547
s->motion_val[xy + 1][1] = motion_y;
548
s->motion_val[xy + wrap][0] = motion_x;
549
s->motion_val[xy + wrap][1] = motion_y;
550
s->motion_val[xy + 1 + wrap][0] = motion_x;
551
s->motion_val[xy + 1 + wrap][1] = motion_y;
701
s->current_picture.motion_val[0][xy][0] = motion_x;
702
s->current_picture.motion_val[0][xy][1] = motion_y;
703
s->current_picture.motion_val[0][xy + 1][0] = motion_x;
704
s->current_picture.motion_val[0][xy + 1][1] = motion_y;
705
s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
706
s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
707
s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
708
s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
552
709
}
553
710
554
711
if(s->encoding){ //FIXME encoding MUST be cleaned up
555
if (s->mv_type == MV_TYPE_8X8)
712
if (s->mv_type == MV_TYPE_8X8)
556
713
s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
714
else if(s->mb_intra)
715
s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
557
716
else
558
717
s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
559
718
}
560
719
}
561
720
562
721
#ifdef CONFIG_ENCODERS
722
723
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
724
int l, bit_size, code;
725
726
if (val == 0) {
727
return mvtab[0][1];
728
} else {
729
bit_size = f_code - 1;
730
/* modulo encoding */
731
l= INT_BIT - 6 - bit_size;
732
val = (val<<l)>>l;
733
val--;
734
code = (val >> bit_size) + 1;
735
736
return mvtab[code][1] + 1 + bit_size;
737
}
738
}
739
740
static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
741
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
742
skip_put_bits(&s->pb,
743
h263_get_motion_length(s, x, f_code)
744
+h263_get_motion_length(s, y, f_code));
745
}else{
746
ff_h263_encode_motion(s, x, f_code);
747
ff_h263_encode_motion(s, y, f_code);
748
}
749
}
750
751
static inline int get_p_cbp(MpegEncContext * s,
752
DCTELEM block[6][64],
753
int motion_x, int motion_y){
754
int cbp, i;
755
756
if(s->flags & CODEC_FLAG_CBP_RD){
757
int best_cbpy_score= INT_MAX;
758
int best_cbpc_score= INT_MAX;
759
int cbpc = (-1), cbpy= (-1);
760
const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
761
const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
762
763
for(i=0; i<4; i++){
764
int score= inter_MCBPC_bits[i + offset] * lambda;
765
if(i&1) score += s->coded_score[5];
766
if(i&2) score += s->coded_score[4];
767
768
if(score < best_cbpc_score){
769
best_cbpc_score= score;
770
cbpc= i;
771
}
772
}
773
774
for(i=0; i<16; i++){
775
int score= cbpy_tab[i ^ 0xF][1] * lambda;
776
if(i&1) score += s->coded_score[3];
777
if(i&2) score += s->coded_score[2];
778
if(i&4) score += s->coded_score[1];
779
if(i&8) score += s->coded_score[0];
780
781
if(score < best_cbpy_score){
782
best_cbpy_score= score;
783
cbpy= i;
784
}
785
}
786
cbp= cbpc + 4*cbpy;
787
if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
788
if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
789
cbp= 0;
790
}
791
792
for (i = 0; i < 6; i++) {
793
if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
794
s->block_last_index[i]= -1;
795
memset(s->block[i], 0, sizeof(DCTELEM)*64);
796
}
797
}
798
}else{
799
cbp= 0;
800
for (i = 0; i < 6; i++) {
801
if (s->block_last_index[i] >= 0)
802
cbp |= 1 << (5 - i);
803
}
804
}
805
return cbp;
806
}
807
808
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
809
int motion_x, int motion_y, int mb_type){
810
int cbp=0, i;
811
812
if(s->flags & CODEC_FLAG_CBP_RD){
813
int score=0;
814
const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
815
816
for(i=0; i<6; i++){
817
if(s->coded_score[i] < 0){
818
score += s->coded_score[i];
819
cbp |= 1 << (5 - i);
820
}
821
}
822
823
if(cbp){
824
int zero_score= -6;
825
if ((motion_x | motion_y | s->dquant | mb_type) == 0){
826
zero_score-= 4; //2*MV + mb_type + cbp bit
827
}
828
829
zero_score*= lambda;
830
if(zero_score <= score){
831
cbp=0;
832
}
833
}
834
835
for (i = 0; i < 6; i++) {
836
if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
837
s->block_last_index[i]= -1;
838
memset(s->block[i], 0, sizeof(DCTELEM)*64);
839
}
840
}
841
}else{
842
for (i = 0; i < 6; i++) {
843
if (s->block_last_index[i] >= 0)
844
cbp |= 1 << (5 - i);
845
}
846
}
847
return cbp;
848
}
849
850
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
851
uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
852
int i;
853
854
if(scan_table){
855
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
856
for (i = 0; i < 6; i++) {
857
skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
858
}
859
}else{
860
/* encode each block */
861
for (i = 0; i < 6; i++) {
862
mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
863
}
864
}
865
}else{
866
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
867
for (i = 0; i < 6; i++) {
868
skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
869
}
870
}else{
871
/* encode each block */
872
for (i = 0; i < 6; i++) {
873
mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
874
}
875
}
876
}
877
}
878
563
879
void mpeg4_encode_mb(MpegEncContext * s,
564
DCTELEM block[6][64],
565
int motion_x, int motion_y)
880
DCTELEM block[6][64],
881
int motion_x, int motion_y)
566
882
{
567
883
int cbpc, cbpy, pred_x, pred_y;
568
884
PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
570
886
PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
571
887
const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
572
888
const int dquant_code[5]= {1,0,9,2,3};
573
889
574
890
// printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
575
891
if (!s->mb_intra) {
576
/* compute cbp */
577
int i, cbp = 0;
578
for (i = 0; i < 6; i++) {
579
if (s->block_last_index[i] >= 0)
580
cbp |= 1 << (5 - i);
581
}
892
int i, cbp;
582
893
583
894
if(s->pict_type==B_TYPE){
584
895
static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
585
896
int mb_type= mb_type_table[s->mv_dir];
586
897
587
898
if(s->mb_x==0){
588
s->last_mv[0][0][0]=
589
s->last_mv[0][0][1]=
590
s->last_mv[1][0][0]=
591
s->last_mv[1][0][1]= 0;
899
for(i=0; i<2; i++){
900
s->last_mv[i][0][0]=
901
s->last_mv[i][0][1]=
902
s->last_mv[i][1][0]=
903
s->last_mv[i][1][1]= 0;
904
}
592
905
}
593
906
594
907
assert(s->dquant>=-2 && s->dquant<=2);
595
908
assert((s->dquant&1)==0);
596
909
assert(mb_type>=0);
597
910
598
/* nothing to do if this MB was skiped in the next P Frame */
911
/* nothing to do if this MB was skipped in the next P Frame */
599
912
if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
600
913
s->skip_count++;
601
s->mv[0][0][0]=
602
s->mv[0][0][1]=
603
s->mv[1][0][0]=
914
s->mv[0][0][0]=
915
s->mv[0][0][1]=
916
s->mv[1][0][0]=
604
917
s->mv[1][0][1]= 0;
605
s->mv_dir= MV_DIR_FORWARD; //doesnt matter
918
s->mv_dir= MV_DIR_FORWARD; //doesn't matter
606
919
s->qscale -= s->dquant;
607
// s->mb_skiped=1;
920
// s->mb_skipped=1;
608
921
609
922
return;
610
923
}
611
924
925
cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
926
612
927
if ((cbp | motion_x | motion_y | mb_type) ==0) {
613
928
/* direct MB with MV={0,0} */
614
929
assert(s->dquant==0);
615
930
616
931
put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
617
932
618
933
if(interleaved_stats){
622
937
s->skip_count++;
623
938
return;
624
939
}
625
626
put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
940
941
put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
627
942
put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
628
put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
943
put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
629
944
if(cbp) put_bits(&s->pb, 6, cbp);
630
945
631
946
if(cbp && mb_type){
632
947
if(s->dquant)
633
948
put_bits(&s->pb, 2, (s->dquant>>2)+3);
635
950
put_bits(&s->pb, 1, 0);
636
951
}else
637
952
s->qscale -= s->dquant;
638
953
639
954
if(!s->progressive_sequence){
640
955
if(cbp)
641
956
put_bits(&s->pb, 1, s->interlaced_dct);
642
if(mb_type) // not diect mode
643
put_bits(&s->pb, 1, 0); // no interlaced ME yet
957
if(mb_type) // not direct mode
958
put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
644
959
}
645
960
646
961
if(interleaved_stats){
647
962
s->misc_bits+= get_bits_diff(s);
648
963
}
649
964
650
switch(mb_type)
651
{
652
case 0: /* direct */
653
h263_encode_motion(s, motion_x, 1);
654
h263_encode_motion(s, motion_y, 1);
655
s->b_count++;
656
s->f_count++;
657
break;
658
case 1: /* bidir */
659
h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
660
h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
661
h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
662
h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
663
s->last_mv[0][0][0]= s->mv[0][0][0];
664
s->last_mv[0][0][1]= s->mv[0][0][1];
665
s->last_mv[1][0][0]= s->mv[1][0][0];
666
s->last_mv[1][0][1]= s->mv[1][0][1];
667
s->b_count++;
668
s->f_count++;
669
break;
670
case 2: /* backward */
671
h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
672
h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
673
s->last_mv[1][0][0]= motion_x;
674
s->last_mv[1][0][1]= motion_y;
675
s->b_count++;
676
break;
677
case 3: /* forward */
678
h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
679
h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
680
s->last_mv[0][0][0]= motion_x;
681
s->last_mv[0][0][1]= motion_y;
682
s->f_count++;
683
break;
684
default:
685
printf("unknown mb type\n");
686
return;
965
if(mb_type == 0){
966
assert(s->mv_dir & MV_DIRECT);
967
ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
968
s->b_count++;
969
s->f_count++;
970
}else{
971
assert(mb_type > 0 && mb_type < 4);
972
if(s->mv_type != MV_TYPE_FIELD){
973
if(s->mv_dir & MV_DIR_FORWARD){
974
ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
975
s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
976
s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
977
s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
978
s->f_count++;
979
}
980
if(s->mv_dir & MV_DIR_BACKWARD){
981
ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
982
s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
983
s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
984
s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
985
s->b_count++;
986
}
987
}else{
988
if(s->mv_dir & MV_DIR_FORWARD){
989
put_bits(&s->pb, 1, s->field_select[0][0]);
990
put_bits(&s->pb, 1, s->field_select[0][1]);
991
}
992
if(s->mv_dir & MV_DIR_BACKWARD){
993
put_bits(&s->pb, 1, s->field_select[1][0]);
994
put_bits(&s->pb, 1, s->field_select[1][1]);
995
}
996
if(s->mv_dir & MV_DIR_FORWARD){
997
for(i=0; i<2; i++){
998
ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
999
s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1000
s->last_mv[0][i][0]= s->mv[0][i][0];
1001
s->last_mv[0][i][1]= s->mv[0][i][1]*2;
1002
}
1003
s->f_count++;
1004
}
1005
if(s->mv_dir & MV_DIR_BACKWARD){
1006
for(i=0; i<2; i++){
1007
ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
1008
s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1009
s->last_mv[1][i][0]= s->mv[1][i][0];
1010
s->last_mv[1][i][1]= s->mv[1][i][1]*2;
1011
}
1012
s->b_count++;
1013
}
1014
}
687
1015
}
688
1016
689
1017
if(interleaved_stats){
690
1018
s->mv_bits+= get_bits_diff(s);
691
1019
}
692
1020
693
/* encode each block */
694
for (i = 0; i < 6; i++) {
695
mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
696
}
1021
mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
697
1022
698
1023
if(interleaved_stats){
699
1024
s->p_tex_bits+= get_bits_diff(s);
700
1025
}
1026
701
1027
}else{ /* s->pict_type==B_TYPE */
1028
cbp= get_p_cbp(s, block, motion_x, motion_y);
1029
702
1030
if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
703
/* check if the B frames can skip it too, as we must skip it if we skip here
704
why didnt they just compress the skip-mb bits instead of reusing them ?! */
1031
/* check if the B frames can skip it too, as we must skip it if we skip here
1032
why didn't they just compress the skip-mb bits instead of reusing them ?! */
705
1033
if(s->max_b_frames>0){
706
1034
int i;
707
1035
int x,y, offset;
714
1042
715
1043
offset= x + y*s->linesize;
716
1044
p_pic= s->new_picture.data[0] + offset;
717
718
s->mb_skiped=1;
1045
1046
s->mb_skipped=1;
719
1047
for(i=0; i<s->max_b_frames; i++){
720
1048
uint8_t *b_pic;
721
1049
int diff;
723
1051
724
1052
if(pic==NULL || pic->pict_type!=B_TYPE) break;
725
1053
726
b_pic= pic->data[0] + offset + 16; //FIXME +16
727
diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);
1054
b_pic= pic->data[0] + offset;
1055
if(pic->type != FF_BUFFER_TYPE_SHARED)
1056
b_pic+= INPLACE_OFFSET;
1057
diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
728
1058
if(diff>s->qscale*70){ //FIXME check that 70 is optimal
729
s->mb_skiped=0;
1059
s->mb_skipped=0;
730
1060
break;
731
1061
}
732
1062
}
733
1063
}else
734
s->mb_skiped=1;
1064
s->mb_skipped=1;
735
1065
736
if(s->mb_skiped==1){
1066
if(s->mb_skipped==1){
737
1067
/* skip macroblock */
738
1068
put_bits(&s->pb, 1, 1);
739
1069
742
1072
s->last_bits++;
743
1073
}
744
1074
s->skip_count++;
745
1075
746
1076
return;
747
1077
}
748
1078
}
749
1079
750
put_bits(&s->pb, 1, 0); /* mb coded */
1080
put_bits(&s->pb, 1, 0); /* mb coded */
1081
cbpc = cbp & 3;
1082
cbpy = cbp >> 2;
1083
cbpy ^= 0xf;
751
1084
if(s->mv_type==MV_TYPE_16X16){
752
cbpc = cbp & 3;
753
1085
if(s->dquant) cbpc+= 8;
754
1086
put_bits(&s->pb,
755
1087
inter_MCBPC_bits[cbpc],
756
1088
inter_MCBPC_code[cbpc]);
757
1089
758
cbpy = cbp >> 2;
759
cbpy ^= 0xf;
760
1090
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
761
1091
if(s->dquant)
762
1092
put_bits(pb2, 2, dquant_code[s->dquant+2]);
764
1094
if(!s->progressive_sequence){
765
1095
if(cbp)
766
1096
put_bits(pb2, 1, s->interlaced_dct);
767
put_bits(pb2, 1, 0); // no interlaced ME yet
1097
put_bits(pb2, 1, 0);
768
1098
}
769
1099
770
1100
if(interleaved_stats){
771
1101
s->misc_bits+= get_bits_diff(s);
772
1102
}
773
1103
774
1104
/* motion vectors: 16x16 mode */
775
h263_pred_motion(s, 0, &pred_x, &pred_y);
776
777
h263_encode_motion(s, motion_x - pred_x, s->f_code);
778
h263_encode_motion(s, motion_y - pred_y, s->f_code);
779
}else{
780
cbpc = (cbp & 3)+16;
1105
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1106
1107
ff_h263_encode_motion_vector(s, motion_x - pred_x,
1108
motion_y - pred_y, s->f_code);
1109
}else if(s->mv_type==MV_TYPE_FIELD){
1110
if(s->dquant) cbpc+= 8;
781
1111
put_bits(&s->pb,
782
1112
inter_MCBPC_bits[cbpc],
783
1113
inter_MCBPC_code[cbpc]);
784
cbpy = cbp >> 2;
785
cbpy ^= 0xf;
1114
1115
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1116
if(s->dquant)
1117
put_bits(pb2, 2, dquant_code[s->dquant+2]);
1118
1119
assert(!s->progressive_sequence);
1120
if(cbp)
1121
put_bits(pb2, 1, s->interlaced_dct);
1122
put_bits(pb2, 1, 1);
1123
1124
if(interleaved_stats){
1125
s->misc_bits+= get_bits_diff(s);
1126
}
1127
1128
/* motion vectors: 16x8 interlaced mode */
1129
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1130
pred_y /=2;
1131
1132
put_bits(&s->pb, 1, s->field_select[0][0]);
1133
put_bits(&s->pb, 1, s->field_select[0][1]);
1134
1135
ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1136
s->mv[0][0][1] - pred_y, s->f_code);
1137
ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1138
s->mv[0][1][1] - pred_y, s->f_code);
1139
}else{
1140
assert(s->mv_type==MV_TYPE_8X8);
1141
put_bits(&s->pb,
1142
inter_MCBPC_bits[cbpc+16],
1143
inter_MCBPC_code[cbpc+16]);
786
1144
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
787
1145
788
1146
if(!s->progressive_sequence){
789
1147
if(cbp)
790
1148
put_bits(pb2, 1, s->interlaced_dct);
791
1149
}
792
1150
793
1151
if(interleaved_stats){
794
1152
s->misc_bits+= get_bits_diff(s);
795
1153
}
796
1154
797
1155
for(i=0; i<4; i++){
798
1156
/* motion vectors: 8x8 mode*/
799
h263_pred_motion(s, i, &pred_x, &pred_y);
1157
h263_pred_motion(s, i, 0, &pred_x, &pred_y);
800
1158
801
h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
802
h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
1159
ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1160
s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
803
1161
}
804
1162
}
805
1163
806
if(interleaved_stats){
1164
if(interleaved_stats){
807
1165
s->mv_bits+= get_bits_diff(s);
808
1166
}
809
1167
810
/* encode each block */
811
for (i = 0; i < 6; i++) {
812
mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
813
}
1168
mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
814
1169
815
1170
if(interleaved_stats){
816
1171
s->p_tex_bits+= get_bits_diff(s);
819
1174
}
820
1175
} else {
821
1176
int cbp;
822
int dc_diff[6]; //dc values with the dc prediction subtracted
1177
int dc_diff[6]; //dc values with the dc prediction subtracted
823
1178
int dir[6]; //prediction direction
824
1179
int zigzag_last_index[6];
825
uint8_t *scan_table[6];
1180
uint8_t *scan_table[6];
826
1181
int i;
827
1182
828
1183
for(i=0; i<6; i++){
829
const int level= block[i][0];
830
uint16_t *dc_ptr;
831
832
dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
833
if (i < 4) {
834
*dc_ptr = level * s->y_dc_scale;
835
} else {
836
*dc_ptr = level * s->c_dc_scale;
837
}
1184
dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
838
1185
}
839
1186
840
s->ac_pred= decide_ac_pred(s, block, dir);
841
842
if(s->ac_pred){
843
for(i=0; i<6; i++){
844
uint8_t *st;
845
int last_index;
846
847
mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
848
if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
849
else st = s->intra_h_scantable.permutated; /* top */
850
851
for(last_index=63; last_index>=0; last_index--) //FIXME optimize
852
if(block[i][st[last_index]]) break;
853
zigzag_last_index[i]= s->block_last_index[i];
854
s->block_last_index[i]= last_index;
855
scan_table[i]= st;
856
}
1187
if(s->flags & CODEC_FLAG_AC_PRED){
1188
s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1189
if(!s->ac_pred)
1190
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
857
1191
}else{
858
1192
for(i=0; i<6; i++)
859
1193
scan_table[i]= s->intra_scantable.permutated;
874
1208
intra_MCBPC_code[cbpc]);
875
1209
} else {
876
1210
if(s->dquant) cbpc+=8;
877
put_bits(&s->pb, 1, 0); /* mb coded */
1211
put_bits(&s->pb, 1, 0); /* mb coded */
878
1212
put_bits(&s->pb,
879
1213
inter_MCBPC_bits[cbpc + 4],
880
1214
inter_MCBPC_code[cbpc + 4]);
893
1227
s->misc_bits+= get_bits_diff(s);
894
1228
}
895
1229
896
/* encode each block */
897
for (i = 0; i < 6; i++) {
898
mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
899
}
1230
mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
900
1231
901
1232
if(interleaved_stats){
902
1233
s->i_tex_bits+= get_bits_diff(s);
904
1235
s->i_count++;
905
1236
906
1237
/* restore ac coeffs & last_index stuff if we messed them up with the prediction */
907
if(s->ac_pred){
908
for(i=0; i<6; i++){
909
int j;
910
int16_t *ac_val;
911
912
ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
913
914
if(dir[i]){
915
for(j=1; j<8; j++)
916
block[i][s->dsp.idct_permutation[j ]]= ac_val[j+8];
917
}else{
918
for(j=1; j<8; j++)
919
block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j ];
920
}
921
s->block_last_index[i]= zigzag_last_index[i];
922
}
923
}
1238
if(s->ac_pred)
1239
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
924
1240
}
925
1241
}
926
1242
927
1243
void h263_encode_mb(MpegEncContext * s,
928
DCTELEM block[6][64],
929
int motion_x, int motion_y)
1244
DCTELEM block[6][64],
1245
int motion_x, int motion_y)
930
1246
{
931
1247
int cbpc, cbpy, i, cbp, pred_x, pred_y;
932
1248
int16_t pred_dc;
933
1249
int16_t rec_intradc[6];
934
uint16_t *dc_ptr[6];
1250
int16_t *dc_ptr[6];
935
1251
const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
936
1252
const int dquant_code[5]= {1,0,9,2,3};
937
1253
938
1254
//printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
939
1255
if (!s->mb_intra) {
940
1256
/* compute cbp */
941
cbp = 0;
942
for (i = 0; i < 6; i++) {
943
if (s->block_last_index[i] >= 0)
944
cbp |= 1 << (5 - i);
945
}
946
if ((cbp | motion_x | motion_y | s->dquant) == 0) {
1257
cbp= get_p_cbp(s, block, motion_x, motion_y);
1258
1259
if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
947
1260
/* skip macroblock */
948
1261
put_bits(&s->pb, 1, 1);
949
1262
if(interleaved_stats){
950
1263
s->misc_bits++;
951
1264
s->last_bits++;
952
1265
}
1266
s->skip_count++;
1267
953
1268
return;
954
1269
}
955
put_bits(&s->pb, 1, 0); /* mb coded */
1270
put_bits(&s->pb, 1, 0); /* mb coded */
1271
956
1272
cbpc = cbp & 3;
1273
cbpy = cbp >> 2;
1274
if(s->alt_inter_vlc==0 || cbpc!=3)
1275
cbpy ^= 0xF;
957
1276
if(s->dquant) cbpc+= 8;
958
put_bits(&s->pb,
959
inter_MCBPC_bits[cbpc],
960
inter_MCBPC_code[cbpc]);
961
cbpy = cbp >> 2;
962
cbpy ^= 0xf;
963
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
964
if(s->dquant)
965
put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
966
967
if(interleaved_stats){
968
s->misc_bits+= get_bits_diff(s);
969
}
970
971
/* motion vectors: 16x16 mode only now */
972
h263_pred_motion(s, 0, &pred_x, &pred_y);
973
974
if (!s->umvplus) {
975
h263_encode_motion(s, motion_x - pred_x, s->f_code);
976
h263_encode_motion(s, motion_y - pred_y, s->f_code);
977
}
978
else {
979
h263p_encode_umotion(s, motion_x - pred_x);
980
h263p_encode_umotion(s, motion_y - pred_y);
981
if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
982
/* To prevent Start Code emulation */
983
put_bits(&s->pb,1,1);
1277
if(s->mv_type==MV_TYPE_16X16){
1278
put_bits(&s->pb,
1279
inter_MCBPC_bits[cbpc],
1280
inter_MCBPC_code[cbpc]);
1281
1282
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1283
if(s->dquant)
1284
put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1285
1286
if(interleaved_stats){
1287
s->misc_bits+= get_bits_diff(s);
1288
}
1289
1290
/* motion vectors: 16x16 mode */
1291
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1292
1293
if (!s->umvplus) {
1294
ff_h263_encode_motion_vector(s, motion_x - pred_x,
1295
motion_y - pred_y, 1);
1296
}
1297
else {
1298
h263p_encode_umotion(s, motion_x - pred_x);
1299
h263p_encode_umotion(s, motion_y - pred_y);
1300
if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1301
/* To prevent Start Code emulation */
1302
put_bits(&s->pb,1,1);
1303
}
1304
}else{
1305
put_bits(&s->pb,
1306
inter_MCBPC_bits[cbpc+16],
1307
inter_MCBPC_code[cbpc+16]);
1308
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1309
if(s->dquant)
1310
put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1311
1312
if(interleaved_stats){
1313
s->misc_bits+= get_bits_diff(s);
1314
}
1315
1316
for(i=0; i<4; i++){
1317
/* motion vectors: 8x8 mode*/
1318
h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1319
1320
motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1321
motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1322
if (!s->umvplus) {
1323
ff_h263_encode_motion_vector(s, motion_x - pred_x,
1324
motion_y - pred_y, 1);
1325
}
1326
else {
1327
h263p_encode_umotion(s, motion_x - pred_x);
1328
h263p_encode_umotion(s, motion_y - pred_y);
1329
if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1330
/* To prevent Start Code emulation */
1331
put_bits(&s->pb,1,1);
1332
}
1333
}
984
1334
}
985
1335
986
1336
if(interleaved_stats){
987
1337
s->mv_bits+= get_bits_diff(s);
988
1338
}
989
1339
} else {
990
int li = s->h263_aic ? 0 : 1;
991
1340
assert(s->mb_intra);
1341
992
1342
cbp = 0;
993
for(i=0; i<6; i++) {
1343
if (s->h263_aic) {
994
1344
/* Predict DC */
995
if (s->h263_aic && s->mb_intra) {
1345
for(i=0; i<6; i++) {
996
1346
int16_t level = block[i][0];
997
1347
int scale;
1348
1349
if(i<4) scale= s->y_dc_scale;
1350
else scale= s->c_dc_scale;
1351
998
1352
pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
999
1353
level -= pred_dc;
1000
1354
/* Quant */
1001
if (level < 0)
1002
level = (level + (s->qscale >> 1))/(s->y_dc_scale);
1355
if (level >= 0)
1356
level = (level + (scale>>1))/scale;
1003
1357
else
1004
level = (level - (s->qscale >> 1))/(s->y_dc_scale);
1005
1358
level = (level - (scale>>1))/scale;
1359
1006
1360
/* AIC can change CBP */
1007
1361
if (level == 0 && s->block_last_index[i] == 0)
1008
1362
s->block_last_index[i] = -1;
1009
else if (level < -127)
1010
level = -127;
1011
else if (level > 127)
1012
level = 127;
1013
1363
1364
if(!s->modified_quant){
1365
if (level < -127)
1366
level = -127;
1367
else if (level > 127)
1368
level = 127;
1369
}
1370
1014
1371
block[i][0] = level;
1015
/* Reconstruction */
1016
rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
1372
/* Reconstruction */
1373
rec_intradc[i] = scale*level + pred_dc;
1017
1374
/* Oddify */
1018
1375
rec_intradc[i] |= 1;
1019
1376
//if ((rec_intradc[i] % 2) == 0)
1023
1380
rec_intradc[i] = 0;
1024
1381
else if (rec_intradc[i] > 2047)
1025
1382
rec_intradc[i] = 2047;
1026
1383
1027
1384
/* Update AC/DC tables */
1028
1385
*dc_ptr[i] = rec_intradc[i];
1029
}
1030
/* compute cbp */
1031
if (s->block_last_index[i] >= li)
1032
cbp |= 1 << (5 - i);
1386
if (s->block_last_index[i] >= 0)
1387
cbp |= 1 << (5 - i);
1388
}
1389
}else{
1390
for(i=0; i<6; i++) {
1391
/* compute cbp */
1392
if (s->block_last_index[i] >= 1)
1393
cbp |= 1 << (5 - i);
1394
}
1033
1395
}
1034
1396
1035
1397
cbpc = cbp & 3;
1040
1402
intra_MCBPC_code[cbpc]);
1041
1403
} else {
1042
1404
if(s->dquant) cbpc+=8;
1043
put_bits(&s->pb, 1, 0); /* mb coded */
1405
put_bits(&s->pb, 1, 0); /* mb coded */
1044
1406
put_bits(&s->pb,
1045
1407
inter_MCBPC_bits[cbpc + 4],
1046
1408
inter_MCBPC_code[cbpc + 4]);
1047
1409
}
1048
1410
if (s->h263_aic) {
1049
1411
/* XXX: currently, we do not try to use ac prediction */
1050
put_bits(&s->pb, 1, 0); /* no AC prediction */
1412
put_bits(&s->pb, 1, 0); /* no AC prediction */
1051
1413
}
1052
1414
cbpy = cbp >> 2;
1053
1415
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1062
1424
for(i=0; i<6; i++) {
1063
1425
/* encode each block */
1064
1426
h263_encode_block(s, block[i], i);
1065
1427
1066
1428
/* Update INTRADC for decoding */
1067
1429
if (s->h263_aic && s->mb_intra) {
1068
1430
block[i][0] = rec_intradc[i];
1069
1431
1070
1432
}
1071
1433
}
1072
1434
1082
1444
}
1083
1445
#endif
1084
1446
1085
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1447
void ff_h263_loop_filter(MpegEncContext * s){
1448
int qp_c;
1449
const int linesize = s->linesize;
1450
const int uvlinesize= s->uvlinesize;
1451
const int xy = s->mb_y * s->mb_stride + s->mb_x;
1452
uint8_t *dest_y = s->dest[0];
1453
uint8_t *dest_cb= s->dest[1];
1454
uint8_t *dest_cr= s->dest[2];
1455
1456
// if(s->pict_type==B_TYPE && !s->readable) return;
1457
1458
/*
1459
Diag Top
1460
Left Center
1461
*/
1462
if(!IS_SKIP(s->current_picture.mb_type[xy])){
1463
qp_c= s->qscale;
1464
s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1465
s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1466
}else
1467
qp_c= 0;
1468
1469
if(s->mb_y){
1470
int qp_dt, qp_t, qp_tc;
1471
1472
if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1473
qp_t=0;
1474
else
1475
qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1476
1477
if(qp_c)
1478
qp_tc= qp_c;
1479
else
1480
qp_tc= qp_t;
1481
1482
if(qp_tc){
1483
const int chroma_qp= s->chroma_qscale_table[qp_tc];
1484
s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1485
s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1486
1487
s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1488
s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1489
}
1490
1491
if(qp_t)
1492
s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1493
1494
if(s->mb_x){
1495
if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1496
qp_dt= qp_t;
1497
else
1498
qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1499
1500
if(qp_dt){
1501
const int chroma_qp= s->chroma_qscale_table[qp_dt];
1502
s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1503
s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1504
s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1505
}
1506
}
1507
}
1508
1509
if(qp_c){
1510
s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1511
if(s->mb_y + 1 == s->mb_height)
1512
s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1513
}
1514
1515
if(s->mb_x){
1516
int qp_lc;
1517
if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1518
qp_lc= qp_c;
1519
else
1520
qp_lc= s->current_picture.qscale_table[xy-1];
1521
1522
if(qp_lc){
1523
s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1524
if(s->mb_y + 1 == s->mb_height){
1525
const int chroma_qp= s->chroma_qscale_table[qp_lc];
1526
s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1527
s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1528
s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1529
}
1530
}
1531
}
1532
}
1533
1534
#ifdef CONFIG_ENCODERS
1535
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
1086
1536
{
1087
1537
int x, y, wrap, a, c, pred_dc, scale;
1088
int16_t *dc_val, *ac_val;
1538
int16_t *dc_val;
1089
1539
1090
1540
/* find prediction */
1091
1541
if (n < 4) {
1092
x = 2 * s->mb_x + 1 + (n & 1);
1093
y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1094
wrap = s->mb_width * 2 + 2;
1542
x = 2 * s->mb_x + (n & 1);
1543
y = 2 * s->mb_y + ((n & 2) >> 1);
1544
wrap = s->b8_stride;
1095
1545
dc_val = s->dc_val[0];
1096
ac_val = s->ac_val[0][0];
1097
1546
scale = s->y_dc_scale;
1098
1547
} else {
1099
x = s->mb_x + 1;
1100
y = s->mb_y + 1;
1101
wrap = s->mb_width + 2;
1548
x = s->mb_x;
1549
y = s->mb_y;
1550
wrap = s->mb_stride;
1102
1551
dc_val = s->dc_val[n - 4 + 1];
1103
ac_val = s->ac_val[n - 4 + 1][0];
1104
1552
scale = s->c_dc_scale;
1105
1553
}
1106
1554
/* B C
1107
* A X
1555
* A X
1108
1556
*/
1109
1557
a = dc_val[(x - 1) + (y) * wrap];
1110
1558
c = dc_val[(x) + (y - 1) * wrap];
1111
1559
1112
1560
/* No prediction outside GOB boundary */
1113
if (s->first_slice_line && ((n < 2) || (n > 3)))
1114
c = 1024;
1561
if(s->first_slice_line && n!=3){
1562
if(n!=2) c= 1024;
1563
if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1564
}
1115
1565
pred_dc = 1024;
1116
1566
/* just DC prediction */
1117
1567
if (a != 1024 && c != 1024)
1120
1570
pred_dc = a;
1121
1571
else
1122
1572
pred_dc = c;
1123
1573
1124
1574
/* we assume pred is positive */
1125
1575
//pred_dc = (pred_dc + (scale >> 1)) / scale;
1126
1576
*dc_val_ptr = &dc_val[x + y * wrap];
1127
1577
return pred_dc;
1128
1578
}
1579
#endif /* CONFIG_ENCODERS */
1129
1580
1130
1581
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1131
1582
{
1134
1585
1135
1586
/* find prediction */
1136
1587
if (n < 4) {
1137
x = 2 * s->mb_x + 1 + (n & 1);
1138
y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
1139
wrap = s->mb_width * 2 + 2;
1588
x = 2 * s->mb_x + (n & 1);
1589
y = 2 * s->mb_y + (n>> 1);
1590
wrap = s->b8_stride;
1140
1591
dc_val = s->dc_val[0];
1141
1592
ac_val = s->ac_val[0][0];
1142
1593
scale = s->y_dc_scale;
1143
1594
} else {
1144
x = s->mb_x + 1;
1145
y = s->mb_y + 1;
1146
wrap = s->mb_width + 2;
1595
x = s->mb_x;
1596
y = s->mb_y;
1597
wrap = s->mb_stride;
1147
1598
dc_val = s->dc_val[n - 4 + 1];
1148
1599
ac_val = s->ac_val[n - 4 + 1][0];
1149
1600
scale = s->c_dc_scale;
1150
1601
}
1151
1602
1152
1603
ac_val += ((y) * wrap + (x)) * 16;
1153
1604
ac_val1 = ac_val;
1154
1605
1155
1606
/* B C
1156
* A X
1607
* A X
1157
1608
*/
1158
1609
a = dc_val[(x - 1) + (y) * wrap];
1159
1610
c = dc_val[(x) + (y - 1) * wrap];
1160
1611
1161
1612
/* No prediction outside GOB boundary */
1162
if (s->first_slice_line && ((n < 2) || (n > 3)))
1163
c = 1024;
1164
pred_dc = 1024;
1613
if(s->first_slice_line && n!=3){
1614
if(n!=2) c= 1024;
1615
if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1616
}
1617
1165
1618
if (s->ac_pred) {
1619
pred_dc = 1024;
1166
1620
if (s->h263_aic_dir) {
1167
1621
/* left prediction */
1168
1622
if (a != 1024) {
1191
1645
else
1192
1646
pred_dc = c;
1193
1647
}
1194
1648
1195
1649
/* we assume pred is positive */
1196
1650
block[0]=block[0]*scale + pred_dc;
1197
1651
1198
1652
if (block[0] < 0)
1199
1653
block[0] = 0;
1200
else if (!(block[0] & 1))
1201
block[0]++;
1202
1654
else
1655
block[0] |= 1;
1656
1203
1657
/* Update AC/DC tables */
1204
1658
dc_val[(x) + (y) * wrap] = block[0];
1205
1659
1206
1660
/* left copy */
1207
1661
for(i=1;i<8;i++)
1208
1662
ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1211
1665
ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1212
1666
}
1213
1667
1214
int16_t *h263_pred_motion(MpegEncContext * s, int block,
1668
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1215
1669
int *px, int *py)
1216
1670
{
1217
int xy, wrap;
1218
int16_t *A, *B, *C, *mot_val;
1671
int wrap;
1672
int16_t *A, *B, *C, (*mot_val)[2];
1219
1673
static const int off[4]= {2, 1, 1, -1};
1220
1674
1221
wrap = s->block_wrap[0];
1222
xy = s->block_index[block];
1223
1224
mot_val = s->motion_val[xy];
1225
1226
A = s->motion_val[xy - 1];
1675
wrap = s->b8_stride;
1676
mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1677
1678
A = mot_val[ - 1];
1227
1679
/* special case for first (slice) line */
1228
1680
if (s->first_slice_line && block<3) {
1229
// we cant just change some MVs to simulate that as we need them for the B frames (and ME)
1681
// we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1230
1682
// and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1231
1683
if(block==0){ //most common case
1232
1684
if(s->mb_x == s->resync_mb_x){ //rare
1233
1685
*px= *py = 0;
1234
}else if(s->mb_x + 1 == s->resync_mb_x){ //rare
1235
C = s->motion_val[xy + off[block] - wrap];
1686
}else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1687
C = mot_val[off[block] - wrap];
1236
1688
if(s->mb_x==0){
1237
1689
*px = C[0];
1238
1690
*py = C[1];
1245
1697
*py = A[1];
1246
1698
}
1247
1699
}else if(block==1){
1248
if(s->mb_x + 1 == s->resync_mb_x){ //rare
1249
C = s->motion_val[xy + off[block] - wrap];
1700
if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1701
C = mot_val[off[block] - wrap];
1250
1702
*px = mid_pred(A[0], 0, C[0]);
1251
1703
*py = mid_pred(A[1], 0, C[1]);
1252
1704
}else{
1254
1706
*py = A[1];
1255
1707
}
1256
1708
}else{ /* block==2*/
1257
B = s->motion_val[xy - wrap];
1258
C = s->motion_val[xy + off[block] - wrap];
1709
B = mot_val[ - wrap];
1710
C = mot_val[off[block] - wrap];
1259
1711
if(s->mb_x == s->resync_mb_x) //rare
1260
1712
A[0]=A[1]=0;
1261
1713
1262
1714
*px = mid_pred(A[0], B[0], C[0]);
1263
1715
*py = mid_pred(A[1], B[1], C[1]);
1264
1716
}
1265
1717
} else {
1266
B = s->motion_val[xy - wrap];
1267
C = s->motion_val[xy + off[block] - wrap];
1718
B = mot_val[ - wrap];
1719
C = mot_val[off[block] - wrap];
1268
1720
*px = mid_pred(A[0], B[0], C[0]);
1269
1721
*py = mid_pred(A[1], B[1], C[1]);
1270
1722
}
1271
return mot_val;
1723
return *mot_val;
1272
1724
}
1273
1725
1274
1726
#ifdef CONFIG_ENCODERS
1275
static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
1727
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1276
1728
{
1277
1729
int range, l, bit_size, sign, code, bits;
1278
1730
1284
1736
bit_size = f_code - 1;
1285
1737
range = 1 << bit_size;
1286
1738
/* modulo encoding */
1287
l = range * 32;
1288
#if 1
1289
val+= l;
1290
val&= 2*l-1;
1291
val-= l;
1739
l= INT_BIT - 6 - bit_size;
1740
val = (val<<l)>>l;
1292
1741
sign = val>>31;
1293
1742
val= (val^sign)-sign;
1294
1743
sign&=1;
1295
#else
1296
if (val < -l) {
1297
val += 2*l;
1298
} else if (val >= l) {
1299
val -= 2*l;
1300
}
1301
1302
assert(val>=-l && val<l);
1303
1304
if (val >= 0) {
1305
sign = 0;
1306
} else {
1307
val = -val;
1308
sign = 1;
1309
}
1310
#endif
1744
1311
1745
val--;
1312
1746
code = (val >> bit_size) + 1;
1313
1747
bits = val & (range - 1);
1314
1748
1315
put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1749
put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1316
1750
if (bit_size > 0) {
1317
1751
put_bits(&s->pb, bit_size, bits);
1318
1752
}
1319
1753
}
1320
1321
1754
}
1322
1755
1323
1756
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1324
1757
static void h263p_encode_umotion(MpegEncContext * s, int val)
1325
1758
{
1326
short sval = 0;
1759
short sval = 0;
1327
1760
short i = 0;
1328
1761
short n_bits = 0;
1329
1762
short temp_val;
1330
1763
int code = 0;
1331
1764
int tcode;
1332
1765
1333
1766
if ( val == 0)
1334
1767
put_bits(&s->pb, 1, 1);
1335
1768
else if (val == 1)
1337
1770
else if (val == -1)
1338
1771
put_bits(&s->pb, 3, 2);
1339
1772
else {
1340
1773
1341
1774
sval = ((val < 0) ? (short)(-val):(short)val);
1342
1775
temp_val = sval;
1343
1776
1344
1777
while (temp_val != 0) {
1345
1778
temp_val = temp_val >> 1;
1346
1779
n_bits++;
1347
1780
}
1348
1781
1349
1782
i = n_bits - 1;
1350
1783
while (i > 0) {
1351
1784
tcode = (sval & (1 << (i-1))) >> (i-1);
1363
1796
{
1364
1797
int f_code;
1365
1798
int mv;
1366
1799
1367
1800
if(mv_penalty==NULL)
1368
1801
mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1369
1802
1370
1803
for(f_code=1; f_code<=MAX_FCODE; f_code++){
1371
1804
for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1372
1805
int len;
1375
1808
else{
1376
1809
int val, bit_size, range, code;
1377
1810
1378
bit_size = s->f_code - 1;
1811
bit_size = f_code - 1;
1379
1812
range = 1 << bit_size;
1380
1813
1381
1814
val=mv;
1382
if (val < 0)
1815
if (val < 0)
1383
1816
val = -val;
1384
1817
val--;
1385
1818
code = (val >> bit_size) + 1;
1386
1819
if(code<33){
1387
1820
len= mvtab[code][1] + 1 + bit_size;
1388
1821
}else{
1389
len= mvtab[32][1] + 2 + bit_size;
1822
len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1390
1823
}
1391
1824
}
1392
1825
1419
1852
v = abs(level);
1420
1853
while (v) {
1421
1854
v >>= 1;
1422
size++;
1855
size++;
1423
1856
}
1424
1857
1425
1858
if (level < 0)
1445
1878
/* chrominance */
1446
1879
uni_code= DCtab_chrom[size][0];
1447
1880
uni_len = DCtab_chrom[size][1];
1448
1881
1449
1882
if (size > 0) {
1450
1883
uni_code<<=size; uni_code|=l;
1451
1884
uni_len+=size;
1465
1898
#ifdef CONFIG_ENCODERS
1466
1899
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1467
1900
int slevel, run, last;
1468
1901
1469
1902
assert(MAX_LEVEL >= 64);
1470
1903
assert(MAX_RUN >= 63);
1471
1904
1478
1911
int sign= slevel < 0 ? 1 : 0;
1479
1912
int bits, len, code;
1480
1913
int level1, run1;
1481
1914
1482
1915
len_tab[index]= 100;
1483
1916
1484
1917
/* ESC0 */
1485
1918
code= get_rl_index(rl, last, run, level);
1486
1919
bits= rl->table_vlc[code][0];
1487
1920
len= rl->table_vlc[code][1];
1488
1921
bits=bits*2+sign; len++;
1489
1922
1490
1923
if(code!=rl->n && len < len_tab[index]){
1491
1924
bits_tab[index]= bits;
1492
1925
len_tab [index]= len;
1503
1936
len += rl->table_vlc[code][1];
1504
1937
bits += rl->table_vlc[code][0];
1505
1938
bits=bits*2+sign; len++;
1506
1939
1507
1940
if(code!=rl->n && len < len_tab[index]){
1508
1941
bits_tab[index]= bits;
1509
1942
len_tab [index]= len;
1510
1943
}
1511
1944
}
1512
#endif
1945
#endif
1513
1946
#if 1
1514
1947
/* ESC2 */
1515
1948
bits= rl->table_vlc[rl->n][0];
1522
1955
len += rl->table_vlc[code][1];
1523
1956
bits += rl->table_vlc[code][0];
1524
1957
bits=bits*2+sign; len++;
1525
1958
1526
1959
if(code!=rl->n && len < len_tab[index]){
1527
1960
bits_tab[index]= bits;
1528
1961
len_tab [index]= len;
1529
1962
}
1530
1963
}
1531
#endif
1532
/* ESC3 */
1964
#endif
1965
/* ESC3 */
1533
1966
bits= rl->table_vlc[rl->n][0];
1534
1967
len = rl->table_vlc[rl->n][1];
1535
1968
bits=bits*4+3; len+=2; //esc3
1538
1971
bits=bits*2+1; len++; //marker
1539
1972
bits=bits*4096+(slevel&0xfff); len+=12;
1540
1973
bits=bits*2+1; len++; //marker
1541
1974
1542
1975
if(len < len_tab[index]){
1543
1976
bits_tab[index]= bits;
1544
1977
len_tab [index]= len;
1548
1981
}
1549
1982
}
1550
1983
1984
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1985
int slevel, run, last;
1986
1987
assert(MAX_LEVEL >= 64);
1988
assert(MAX_RUN >= 63);
1989
1990
for(slevel=-64; slevel<64; slevel++){
1991
if(slevel==0) continue;
1992
for(run=0; run<64; run++){
1993
for(last=0; last<=1; last++){
1994
const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1995
int level= slevel < 0 ? -slevel : slevel;
1996
int sign= slevel < 0 ? 1 : 0;
1997
int bits, len, code;
1998
1999
len_tab[index]= 100;
2000
2001
/* ESC0 */
2002
code= get_rl_index(rl, last, run, level);
2003
bits= rl->table_vlc[code][0];
2004
len= rl->table_vlc[code][1];
2005
bits=bits*2+sign; len++;
2006
2007
if(code!=rl->n && len < len_tab[index]){
2008
if(bits_tab) bits_tab[index]= bits;
2009
len_tab [index]= len;
2010
}
2011
/* ESC */
2012
bits= rl->table_vlc[rl->n][0];
2013
len = rl->table_vlc[rl->n][1];
2014
bits=bits*2+last; len++;
2015
bits=bits*64+run; len+=6;
2016
bits=bits*256+(level&0xff); len+=8;
2017
2018
if(len < len_tab[index]){
2019
if(bits_tab) bits_tab[index]= bits;
2020
len_tab [index]= len;
2021
}
2022
}
2023
}
2024
}
2025
}
2026
1551
2027
void h263_encode_init(MpegEncContext *s)
1552
2028
{
1553
2029
static int done = 0;
1557
2033
1558
2034
init_uni_dc_tab();
1559
2035
1560
init_rl(&rl_inter);
1561
init_rl(&rl_intra);
1562
init_rl(&rl_intra_aic);
1563
2036
init_rl(&rl_inter, 1);
2037
init_rl(&rl_intra, 1);
2038
init_rl(&rl_intra_aic, 1);
2039
1564
2040
init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1565
2041
init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1566
2042
2043
init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
2044
init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
2045
1567
2046
init_mv_penalty_and_fcode(s);
1568
2047
}
1569
2048
s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1570
2049
2050
s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
2051
s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
2052
if(s->h263_aic){
2053
s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
2054
s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2055
}
2056
s->ac_esc_length= 7+1+6+8;
2057
1571
2058
// use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1572
2059
switch(s->codec_id){
1573
2060
case CODEC_ID_MPEG4:
1581
2068
s->luma_dc_vlc_length= uni_DCtab_lum_len;
1582
2069
s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
1583
2070
s->ac_esc_length= 7+2+1+6+1+12+1;
1584
2071
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2072
s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2073
1585
2074
if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1586
2075
1587
2076
s->avctx->extradata= av_malloc(1024);
1588
init_put_bits(&s->pb, s->avctx->extradata, 1024, NULL, NULL);
1589
1590
mpeg4_encode_visual_object_header(s);
2077
init_put_bits(&s->pb, s->avctx->extradata, 1024);
2078
2079
if(!(s->workaround_bugs & FF_BUG_MS))
2080
mpeg4_encode_visual_object_header(s);
1591
2081
mpeg4_encode_vol_header(s, 0, 0);
1592
2082
1593
2083
// ff_mpeg4_stuffing(&s->pb); ?
1594
2084
flush_put_bits(&s->pb);
1595
s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3;
2085
s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
1596
2086
}
1597
2087
1598
2088
break;
1599
2089
case CODEC_ID_H263P:
1600
s->fcode_tab= umv_fcode_tab;
1601
s->min_qcoeff= -127;
1602
s->max_qcoeff= 127;
2090
if(s->umvplus)
2091
s->fcode_tab= umv_fcode_tab;
2092
if(s->modified_quant){
2093
s->min_qcoeff= -2047;
2094
s->max_qcoeff= 2047;
2095
}else{
2096
s->min_qcoeff= -127;
2097
s->max_qcoeff= 127;
2098
}
1603
2099
break;
1604
//Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2100
//Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1605
2101
case CODEC_ID_FLV1:
1606
2102
if (s->h263_flv > 1) {
1607
2103
s->min_qcoeff= -1023;
1613
2109
s->y_dc_scale_table=
1614
2110
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1615
2111
break;
1616
default: //nothing needed default table allready set in mpegvideo.c
2112
default: //nothing needed - default table already set in mpegvideo.c
1617
2113
s->min_qcoeff= -127;
1618
2114
s->max_qcoeff= 127;
1619
2115
s->y_dc_scale_table=
1648
2144
if (level == 128) //FIXME check rv10
1649
2145
put_bits(&s->pb, 8, 0xff);
1650
2146
else
1651
put_bits(&s->pb, 8, level & 0xff);
2147
put_bits(&s->pb, 8, level);
1652
2148
i = 1;
1653
2149
} else {
1654
2150
i = 0;
1655
2151
if (s->h263_aic && s->mb_intra)
1656
2152
rl = &rl_intra_aic;
2153
2154
if(s->alt_inter_vlc && !s->mb_intra){
2155
int aic_vlc_bits=0;
2156
int inter_vlc_bits=0;
2157
int wrong_pos=-1;
2158
int aic_code;
2159
2160
last_index = s->block_last_index[n];
2161
last_non_zero = i - 1;
2162
for (; i <= last_index; i++) {
2163
j = s->intra_scantable.permutated[i];
2164
level = block[j];
2165
if (level) {
2166
run = i - last_non_zero - 1;
2167
last = (i == last_index);
2168
2169
if(level<0) level= -level;
2170
2171
code = get_rl_index(rl, last, run, level);
2172
aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2173
inter_vlc_bits += rl->table_vlc[code][1]+1;
2174
aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2175
2176
if (code == rl->n) {
2177
inter_vlc_bits += 1+6+8-1;
2178
}
2179
if (aic_code == rl_intra_aic.n) {
2180
aic_vlc_bits += 1+6+8-1;
2181
wrong_pos += run + 1;
2182
}else
2183
wrong_pos += wrong_run[aic_code];
2184
last_non_zero = i;
2185
}
2186
}
2187
i = 0;
2188
if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2189
rl = &rl_intra_aic;
2190
}
1657
2191
}
1658
2192
1659
2193
/* AC coefs */
1660
2194
last_index = s->block_last_index[n];
1661
2195
last_non_zero = i - 1;
1677
2211
if(s->h263_flv <= 1){
1678
2212
put_bits(&s->pb, 1, last);
1679
2213
put_bits(&s->pb, 6, run);
1680
2214
1681
2215
assert(slevel != 0);
1682
2216
1683
if(slevel < 128 && slevel > -128)
2217
if(level < 128)
1684
2218
put_bits(&s->pb, 8, slevel & 0xff);
1685
2219
else{
1686
2220
put_bits(&s->pb, 8, 128);
1688
2222
put_bits(&s->pb, 6, (slevel>>5)&0x3f);
1689
2223
}
1690
2224
}else{
1691
if(slevel < 64 && slevel > -64) {
1692
/* 7-bit level */
2225
if(level < 64) { // 7-bit level
1693
2226
put_bits(&s->pb, 1, 0);
1694
2227
put_bits(&s->pb, 1, last);
1695
2228
put_bits(&s->pb, 6, run);
1723
2256
{
1724
2257
int length;
1725
2258
put_bits(pbc, 1, 0);
1726
length= (-get_bit_count(pbc))&7;
2259
length= (-put_bits_count(pbc))&7;
1727
2260
if(length) put_bits(pbc, length, (1<<length)-1);
1728
2261
}
1729
2262
1731
2264
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1732
2265
int time_div, time_mod;
1733
2266
1734
if(s->current_picture.pts)
1735
s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
1736
else
1737
s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
1738
time_div= s->time/s->time_increment_resolution;
1739
time_mod= s->time%s->time_increment_resolution;
2267
assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2268
s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2269
2270
time_div= s->time/s->avctx->time_base.den;
2271
time_mod= s->time%s->avctx->time_base.den;
1740
2272
1741
2273
if(s->pict_type==B_TYPE){
1742
2274
s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2275
assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2276
ff_mpeg4_init_direct_mv(s);
1743
2277
}else{
1744
2278
s->last_time_base= s->time_base;
1745
2279
s->time_base= time_div;
1746
2280
s->pp_time= s->time - s->last_non_b_time;
1747
2281
s->last_non_b_time= s->time;
2282
assert(picture_number==0 || s->pp_time > 0);
1748
2283
}
1749
2284
}
1750
2285
1751
2286
static void mpeg4_encode_gop_header(MpegEncContext * s){
1752
2287
int hours, minutes, seconds;
1753
2288
int64_t time;
2289
1754
2290
put_bits(&s->pb, 16, 0);
1755
2291
put_bits(&s->pb, 16, GOP_STARTCODE);
1756
1757
seconds= s->time/s->time_increment_resolution;
2292
2293
time= s->current_picture_ptr->pts;
2294
if(s->reordered_input_picture[1])
2295
time= FFMIN(time, s->reordered_input_picture[1]->pts);
2296
time= time*s->avctx->time_base.num;
2297
2298
seconds= time/s->avctx->time_base.den;
1758
2299
minutes= seconds/60; seconds %= 60;
1759
2300
hours= minutes/60; minutes %= 60;
1760
2301
hours%=24;
1763
2304
put_bits(&s->pb, 6, minutes);
1764
2305
put_bits(&s->pb, 1, 1);
1765
2306
put_bits(&s->pb, 6, seconds);
1766
1767
put_bits(&s->pb, 1, 0); //closed gov == NO
2307
2308
put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
1768
2309
put_bits(&s->pb, 1, 0); //broken link == NO
1769
2310
2311
s->last_time_base= time / s->avctx->time_base.den;
2312
1770
2313
ff_mpeg4_stuffing(&s->pb);
1771
2314
}
1772
2315
1773
2316
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
1774
2317
int profile_and_level_indication;
1775
2318
int vo_ver_id;
1776
1777
if(s->max_b_frames || s->quarter_sample){
1778
profile_and_level_indication= 0xF1; // adv simple level 1
2319
2320
if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2321
profile_and_level_indication = s->avctx->profile << 4;
2322
}else if(s->max_b_frames || s->quarter_sample){
2323
profile_and_level_indication= 0xF0; // adv simple
2324
}else{
2325
profile_and_level_indication= 0x00; // simple
2326
}
2327
2328
if(s->avctx->level != FF_LEVEL_UNKNOWN){
2329
profile_and_level_indication |= s->avctx->level;
2330
}else{
2331
profile_and_level_indication |= 1; //level 1
2332
}
2333
2334
if(profile_and_level_indication>>4 == 0xF){
1779
2335
vo_ver_id= 5;
1780
2336
}else{
1781
profile_and_level_indication= 0x01; // simple level 1
1782
2337
vo_ver_id= 1;
1783
2338
}
2339
1784
2340
//FIXME levels
1785
2341
1786
2342
put_bits(&s->pb, 16, 0);
1790
2346
1791
2347
put_bits(&s->pb, 16, 0);
1792
2348
put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
1793
2349
1794
2350
put_bits(&s->pb, 1, 1);
1795
2351
put_bits(&s->pb, 4, vo_ver_id);
1796
2352
put_bits(&s->pb, 3, 1); //priority
1797
2353
1798
2354
put_bits(&s->pb, 4, 1); //visual obj type== video obj
1799
2355
1800
2356
put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
1801
2357
1802
2358
ff_mpeg4_stuffing(&s->pb);
1819
2375
put_bits(&s->pb, 16, 0);
1820
2376
put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
1821
2377
1822
put_bits(&s->pb, 1, 0); /* random access vol */
1823
put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
1824
put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
1825
put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
1826
put_bits(&s->pb, 3, 1); /* is obj layer priority */
1827
1828
float_aspect_to_info(s, s->avctx->aspect_ratio);
2378
put_bits(&s->pb, 1, 0); /* random access vol */
2379
put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2380
if(s->workaround_bugs & FF_BUG_MS) {
2381
put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2382
} else {
2383
put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2384
put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2385
put_bits(&s->pb, 3, 1); /* is obj layer priority */
2386
}
2387
2388
aspect_to_info(s, s->avctx->sample_aspect_ratio);
1829
2389
1830
2390
put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1831
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
1832
{
1833
put_bits(&s->pb, 8, s->aspected_width);
1834
put_bits(&s->pb, 8, s->aspected_height);
2391
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2392
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2393
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
1835
2394
}
1836
2395
1837
if(s->low_delay){
1838
put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1839
put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2396
if(s->workaround_bugs & FF_BUG_MS) { //
2397
put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2398
} else {
2399
put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2400
put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1840
2401
put_bits(&s->pb, 1, s->low_delay);
1841
put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1842
}else{
1843
put_bits(&s->pb, 1, 0); /* vol control parameters= no */
2402
put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1844
2403
}
1845
2404
1846
put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1847
put_bits(&s->pb, 1, 1); /* marker bit */
1848
1849
put_bits(&s->pb, 16, s->time_increment_resolution);
2405
put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2406
put_bits(&s->pb, 1, 1); /* marker bit */
2407
2408
put_bits(&s->pb, 16, s->avctx->time_base.den);
1850
2409
if (s->time_increment_bits < 1)
1851
2410
s->time_increment_bits = 1;
1852
put_bits(&s->pb, 1, 1); /* marker bit */
1853
put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1854
put_bits(&s->pb, 1, 1); /* marker bit */
1855
put_bits(&s->pb, 13, s->width); /* vol width */
1856
put_bits(&s->pb, 1, 1); /* marker bit */
1857
put_bits(&s->pb, 13, s->height); /* vol height */
1858
put_bits(&s->pb, 1, 1); /* marker bit */
2411
put_bits(&s->pb, 1, 1); /* marker bit */
2412
put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2413
put_bits(&s->pb, 1, 1); /* marker bit */
2414
put_bits(&s->pb, 13, s->width); /* vol width */
2415
put_bits(&s->pb, 1, 1); /* marker bit */
2416
put_bits(&s->pb, 13, s->height); /* vol height */
2417
put_bits(&s->pb, 1, 1); /* marker bit */
1859
2418
put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1860
put_bits(&s->pb, 1, 1); /* obmc disable */
2419
put_bits(&s->pb, 1, 1); /* obmc disable */
1861
2420
if (vo_ver_id == 1) {
1862
put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
2421
put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
1863
2422
}else{
1864
put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
2423
put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
1865
2424
}
1866
1867
s->quant_precision=5;
1868
put_bits(&s->pb, 1, 0); /* not 8 bit == false */
1869
put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2425
2426
put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2427
put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1870
2428
1871
2429
if(s->mpeg_quant){
1872
2430
ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
1875
2433
1876
2434
if (vo_ver_id != 1)
1877
2435
put_bits(&s->pb, 1, s->quarter_sample);
1878
put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2436
put_bits(&s->pb, 1, 1); /* complexity estimation disable */
1879
2437
s->resync_marker= s->rtp_mode;
1880
2438
put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1881
2439
put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1882
2440
if(s->data_partitioning){
1883
put_bits(&s->pb, 1, 0); /* no rvlc */
2441
put_bits(&s->pb, 1, 0); /* no rvlc */
1884
2442
}
1885
2443
1886
2444
if (vo_ver_id != 1){
1887
put_bits(&s->pb, 1, 0); /* newpred */
1888
put_bits(&s->pb, 1, 0); /* reduced res vop */
2445
put_bits(&s->pb, 1, 0); /* newpred */
2446
put_bits(&s->pb, 1, 0); /* reduced res vop */
1889
2447
}
1890
put_bits(&s->pb, 1, 0); /* scalability */
1891
2448
put_bits(&s->pb, 1, 0); /* scalability */
2449
1892
2450
ff_mpeg4_stuffing(&s->pb);
1893
2451
1894
2452
/* user data */
1895
2453
if(!(s->flags & CODEC_FLAG_BITEXACT)){
1896
2454
put_bits(&s->pb, 16, 0);
1897
put_bits(&s->pb, 16, 0x1B2); /* user_data */
1898
put_string(&s->pb, LIBAVCODEC_IDENT);
1899
ff_mpeg4_stuffing(&s->pb);
2455
put_bits(&s->pb, 16, 0x1B2); /* user_data */
2456
ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
1900
2457
}
1901
2458
}
1902
2459
1905
2462
{
1906
2463
int time_incr;
1907
2464
int time_div, time_mod;
1908
2465
1909
2466
if(s->pict_type==I_TYPE){
1910
2467
if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1911
if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
2468
if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
1912
2469
mpeg4_encode_visual_object_header(s);
1913
if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
2470
if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
1914
2471
mpeg4_encode_vol_header(s, 0, 0);
1915
2472
}
1916
mpeg4_encode_gop_header(s);
2473
if(!(s->workaround_bugs & FF_BUG_MS))
2474
mpeg4_encode_gop_header(s);
1917
2475
}
1918
2476
1919
2477
s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
1920
2478
1921
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1922
1923
put_bits(&s->pb, 16, 0); /* vop header */
1924
put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
1925
put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
1926
1927
time_div= s->time/s->time_increment_resolution;
1928
time_mod= s->time%s->time_increment_resolution;
2479
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2480
2481
put_bits(&s->pb, 16, 0); /* vop header */
2482
put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2483
put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2484
2485
assert(s->time>=0);
2486
time_div= s->time/s->avctx->time_base.den;
2487
time_mod= s->time%s->avctx->time_base.den;
1929
2488
time_incr= time_div - s->last_time_base;
2489
assert(time_incr >= 0);
1930
2490
while(time_incr--)
1931
2491
put_bits(&s->pb, 1, 1);
1932
2492
1933
2493
put_bits(&s->pb, 1, 0);
1934
2494
1935
put_bits(&s->pb, 1, 1); /* marker */
1936
put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1937
put_bits(&s->pb, 1, 1); /* marker */
1938
put_bits(&s->pb, 1, 1); /* vop coded */
1939
if ( s->pict_type == P_TYPE
2495
put_bits(&s->pb, 1, 1); /* marker */
2496
put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2497
put_bits(&s->pb, 1, 1); /* marker */
2498
put_bits(&s->pb, 1, 1); /* vop coded */
2499
if ( s->pict_type == P_TYPE
1940
2500
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1941
put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2501
put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1942
2502
}
1943
put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2503
put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1944
2504
if(!s->progressive_sequence){
1945
put_bits(&s->pb, 1, s->top_field_first);
2505
put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
1946
2506
put_bits(&s->pb, 1, s->alternate_scan);
1947
2507
}
1948
2508
//FIXME sprite stuff
1950
2510
put_bits(&s->pb, 5, s->qscale);
1951
2511
1952
2512
if (s->pict_type != I_TYPE)
1953
put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2513
put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1954
2514
if (s->pict_type == B_TYPE)
1955
put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2515
put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1956
2516
// printf("****frame %d\n", picture_number);
1957
1958
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1959
s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1960
2517
}
1961
2518
1962
2519
#endif //CONFIG_ENCODERS
1963
2520
1964
2521
/**
1965
* change qscale by given dquant and update qscale dependant variables.
2522
* set qscale and update qscale dependent variables.
1966
2523
*/
1967
static void change_qscale(MpegEncContext * s, int dquant)
2524
void ff_set_qscale(MpegEncContext * s, int qscale)
1968
2525
{
1969
s->qscale += dquant;
1970
1971
if (s->qscale < 1)
1972
s->qscale = 1;
1973
else if (s->qscale > 31)
1974
s->qscale = 31;
1975
1976
s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1977
s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2526
if (qscale < 1)
2527
qscale = 1;
2528
else if (qscale > 31)
2529
qscale = 31;
2530
2531
s->qscale = qscale;
2532
s->chroma_qscale= s->chroma_qscale_table[qscale];
2533
2534
s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2535
s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
1978
2536
}
1979
2537
1980
2538
/**
1981
2539
* predicts the dc.
2540
* encoding quantized level -> quantized diff
2541
* decoding quantized diff -> quantized level
1982
2542
* @param n block index (0-3 are luma, 4-5 are chroma)
1983
* @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
1984
2543
* @param dir_ptr pointer to an integer where the prediction direction will be stored
1985
* @return the quantized predicted dc
1986
2544
*/
1987
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
2545
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
1988
2546
{
1989
int a, b, c, wrap, pred, scale;
1990
uint16_t *dc_val;
2547
int a, b, c, wrap, pred, scale, ret;
2548
int16_t *dc_val;
1991
2549
1992
2550
/* find prediction */
1993
2551
if (n < 4) {
1994
scale = s->y_dc_scale;
2552
scale = s->y_dc_scale;
1995
2553
} else {
1996
scale = s->c_dc_scale;
2554
scale = s->c_dc_scale;
1997
2555
}
1998
2556
if(IS_3IV1)
1999
2557
scale= 8;
2002
2560
dc_val = s->dc_val[0] + s->block_index[n];
2003
2561
2004
2562
/* B C
2005
* A X
2563
* A X
2006
2564
*/
2007
2565
a = dc_val[ - 1];
2008
2566
b = dc_val[ - 1 - wrap];
2009
2567
c = dc_val[ - wrap];
2010
2568
2011
/* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
2569
/* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2012
2570
if(s->first_slice_line && n!=3){
2013
2571
if(n!=2) b=c= 1024;
2014
2572
if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2019
2577
}
2020
2578
2021
2579
if (abs(a - b) < abs(b - c)) {
2022
pred = c;
2580
pred = c;
2023
2581
*dir_ptr = 1; /* top */
2024
2582
} else {
2025
pred = a;
2583
pred = a;
2026
2584
*dir_ptr = 0; /* left */
2027
2585
}
2028
2586
/* we assume pred is positive */
2029
2587
pred = FASTDIV((pred + (scale >> 1)), scale);
2030
2588
2031
/* prepare address for prediction update */
2032
*dc_val_ptr = &dc_val[0];
2589
if(encoding){
2590
ret = level - pred;
2591
}else{
2592
level += pred;
2593
ret= level;
2594
if(s->error_resilience>=3){
2595
if(level<0){
2596
av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2597
return -1;
2598
}
2599
if(level*scale > 2048 + scale){
2600
av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2601
return -1;
2602
}
2603
}
2604
}
2605
level *=scale;
2606
if(level&(~2047)){
2607
if(level<0)
2608
level=0;
2609
else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2610
level=2047;
2611
}
2612
dc_val[0]= level;
2033
2613
2034
return pred;
2614
return ret;
2035
2615
}
2036
2616
2037
2617
/**
2054
2634
const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2055
2635
/* left prediction */
2056
2636
ac_val -= 16;
2057
2637
2058
2638
if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2059
2639
/* same qscale */
2060
2640
for(i=1;i<8;i++) {
2096
2676
2097
2677
#ifdef CONFIG_ENCODERS
2098
2678
2099
static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2100
int dir)
2101
{
2102
int i;
2103
int16_t *ac_val;
2104
int8_t * const qscale_table= s->current_picture.qscale_table;
2105
2106
/* find prediction */
2107
ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2108
2109
if (dir == 0) {
2110
const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2111
/* left prediction */
2112
ac_val -= 16;
2113
if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2114
/* same qscale */
2115
for(i=1;i<8;i++) {
2116
block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
2117
}
2118
}else{
2119
/* different qscale, we must rescale */
2120
for(i=1;i<8;i++) {
2121
block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2122
}
2123
}
2124
} else {
2125
const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2126
/* top prediction */
2127
ac_val -= 16 * s->block_wrap[n];
2128
if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2129
/* same qscale */
2130
for(i=1;i<8;i++) {
2131
block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
2132
}
2133
}else{
2134
/* different qscale, we must rescale */
2135
for(i=1;i<8;i++) {
2136
block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2137
}
2138
}
2139
}
2140
}
2141
2142
2679
/**
2143
2680
* encodes the dc value.
2144
2681
* @param n block index (0-3 are luma, 4-5 are chroma)
2149
2686
// if(level<-255 || level>255) printf("dc overflow\n");
2150
2687
level+=256;
2151
2688
if (n < 4) {
2152
/* luminance */
2153
put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2689
/* luminance */
2690
put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2154
2691
} else {
2155
/* chrominance */
2156
put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2692
/* chrominance */
2693
put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2157
2694
}
2158
2695
#else
2159
2696
int size, v;
2161
2698
size = 0;
2162
2699
v = abs(level);
2163
2700
while (v) {
2164
v >>= 1;
2165
size++;
2701
v >>= 1;
2702
size++;
2166
2703
}
2167
2704
2168
2705
if (n < 4) {
2169
/* luminance */
2170
put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2706
/* luminance */
2707
put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2171
2708
} else {
2172
/* chrominance */
2173
put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2709
/* chrominance */
2710
put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2174
2711
}
2175
2712
2176
2713
/* encode remaining bits */
2177
2714
if (size > 0) {
2178
if (level < 0)
2179
level = (-level) ^ ((1 << size) - 1);
2180
put_bits(&s->pb, size, level);
2181
if (size > 8)
2182
put_bits(&s->pb, 1, 1);
2715
if (level < 0)
2716
level = (-level) ^ ((1 << size) - 1);
2717
put_bits(&s->pb, size, level);
2718
if (size > 8)
2719
put_bits(&s->pb, 1, 1);
2183
2720
}
2184
2721
#endif
2185
2722
}
2186
2723
2724
static inline int mpeg4_get_dc_length(int level, int n){
2725
if (n < 4) {
2726
return uni_DCtab_lum_len[level + 256];
2727
} else {
2728
return uni_DCtab_chrom_len[level + 256];
2729
}
2730
}
2731
2187
2732
/**
2188
2733
* encodes a 8x8 block
2189
2734
* @param n block index (0-3 are luma, 4-5 are chroma)
2190
2735
*/
2191
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2736
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2192
2737
uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2193
2738
{
2194
2739
int i, last_non_zero;
2201
2746
const int last_index = s->block_last_index[n];
2202
2747
2203
2748
if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2204
/* mpeg4 based DC predictor */
2205
mpeg4_encode_dc(dc_pb, intra_dc, n);
2749
/* mpeg4 based DC predictor */
2750
mpeg4_encode_dc(dc_pb, intra_dc, n);
2206
2751
if(last_index<1) return;
2207
i = 1;
2752
i = 1;
2208
2753
rl = &rl_intra;
2209
2754
bits_tab= uni_mpeg4_intra_rl_bits;
2210
2755
len_tab = uni_mpeg4_intra_rl_len;
2211
2756
} else {
2212
2757
if(last_index<0) return;
2213
i = 0;
2758
i = 0;
2214
2759
rl = &rl_inter;
2215
2760
bits_tab= uni_mpeg4_inter_rl_bits;
2216
2761
len_tab = uni_mpeg4_inter_rl_len;
2220
2765
last_non_zero = i - 1;
2221
2766
#if 1
2222
2767
for (; i < last_index; i++) {
2223
int level = block[ scan_table[i] ];
2224
if (level) {
2225
int run = i - last_non_zero - 1;
2768
int level = block[ scan_table[i] ];
2769
if (level) {
2770
int run = i - last_non_zero - 1;
2226
2771
level+=64;
2227
2772
if((level&(~127)) == 0){
2228
2773
const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2230
2775
}else{ //ESC3
2231
2776
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);
2232
2777
}
2233
last_non_zero = i;
2234
}
2778
last_non_zero = i;
2779
}
2235
2780
}
2236
2781
/*if(i<=last_index)*/{
2237
int level = block[ scan_table[i] ];
2782
int level = block[ scan_table[i] ];
2238
2783
int run = i - last_non_zero - 1;
2239
2784
level+=64;
2240
2785
if((level&(~127)) == 0){
2246
2791
}
2247
2792
#else
2248
2793
for (; i <= last_index; i++) {
2249
const int slevel = block[ scan_table[i] ];
2250
if (slevel) {
2794
const int slevel = block[ scan_table[i] ];
2795
if (slevel) {
2251
2796
int level;
2252
int run = i - last_non_zero - 1;
2253
last = (i == last_index);
2254
sign = 0;
2255
level = slevel;
2256
if (level < 0) {
2257
sign = 1;
2258
level = -level;
2259
}
2797
int run = i - last_non_zero - 1;
2798
last = (i == last_index);
2799
sign = 0;
2800
level = slevel;
2801
if (level < 0) {
2802
sign = 1;
2803
level = -level;
2804
}
2260
2805
code = get_rl_index(rl, last, run, level);
2261
2806
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2262
2807
if (code == rl->n) {
2263
2808
int level1, run1;
2264
2809
level1 = level - rl->max_level[last][run];
2265
if (level1 < 1)
2810
if (level1 < 1)
2266
2811
goto esc2;
2267
2812
code = get_rl_index(rl, last, run, level1);
2268
2813
if (code == rl->n) {
2298
2843
} else {
2299
2844
put_bits(ac_pb, 1, sign);
2300
2845
}
2301
last_non_zero = i;
2302
}
2846
last_non_zero = i;
2847
}
2303
2848
}
2304
2849
#endif
2305
2850
}
2306
2851
2307
static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2852
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2308
2853
uint8_t *scan_table)
2309
2854
{
2310
2855
int i, last_non_zero;
2314
2859
int len=0;
2315
2860
2316
2861
if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2317
/* mpeg4 based DC predictor */
2318
//mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
2862
/* mpeg4 based DC predictor */
2863
len += mpeg4_get_dc_length(intra_dc, n);
2319
2864
if(last_index<1) return len;
2320
i = 1;
2865
i = 1;
2321
2866
rl = &rl_intra;
2322
2867
len_tab = uni_mpeg4_intra_rl_len;
2323
2868
} else {
2324
2869
if(last_index<0) return 0;
2325
i = 0;
2870
i = 0;
2326
2871
rl = &rl_inter;
2327
2872
len_tab = uni_mpeg4_inter_rl_len;
2328
2873
}
2330
2875
/* AC coefs */
2331
2876
last_non_zero = i - 1;
2332
2877
for (; i < last_index; i++) {
2333
int level = block[ scan_table[i] ];
2334
if (level) {
2335
int run = i - last_non_zero - 1;
2878
int level = block[ scan_table[i] ];
2879
if (level) {
2880
int run = i - last_non_zero - 1;
2336
2881
level+=64;
2337
2882
if((level&(~127)) == 0){
2338
2883
const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2340
2885
}else{ //ESC3
2341
2886
len += 7+2+1+6+1+12+1;
2342
2887
}
2343
last_non_zero = i;
2344
}
2888
last_non_zero = i;
2889
}
2345
2890
}
2346
2891
/*if(i<=last_index)*/{
2347
int level = block[ scan_table[i] ];
2892
int level = block[ scan_table[i] ];
2348
2893
int run = i - last_non_zero - 1;
2349
2894
level+=64;
2350
2895
if((level&(~127)) == 0){
2354
2899
len += 7+2+1+6+1+12+1;
2355
2900
}
2356
2901
}
2357
2902
2358
2903
return len;
2359
2904
}
2360
2905
2371
2916
static VLC dc_lum, dc_chrom;
2372
2917
static VLC sprite_trajectory;
2373
2918
static VLC mb_type_b_vlc;
2919
static VLC h263_mbtype_b_vlc;
2920
static VLC cbpc_b_vlc;
2374
2921
2375
void init_vlc_rl(RLTable *rl)
2922
void init_vlc_rl(RLTable *rl, int use_static)
2376
2923
{
2377
2924
int i, q;
2378
2379
init_vlc(&rl->vlc, 9, rl->n + 1,
2925
2926
/* Return if static table is already initialized */
2927
if(use_static && rl->rl_vlc[0])
2928
return;
2929
2930
init_vlc(&rl->vlc, 9, rl->n + 1,
2380
2931
&rl->table_vlc[0][1], 4, 2,
2381
&rl->table_vlc[0][0], 4, 2);
2382
2383
2932
&rl->table_vlc[0][0], 4, 2, use_static);
2933
2934
2384
2935
for(q=0; q<32; q++){
2385
2936
int qmul= q*2;
2386
2937
int qadd= (q-1)|1;
2387
2938
2388
2939
if(q==0){
2389
2940
qmul=1;
2390
2941
qadd=0;
2391
2942
}
2392
2393
rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2943
if(use_static)
2944
rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2945
else
2946
rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2394
2947
for(i=0; i<rl->vlc.table_size; i++){
2395
2948
int code= rl->vlc.table[i][0];
2396
2949
int len = rl->vlc.table[i][1];
2397
2950
int level, run;
2398
2951
2399
2952
if(len==0){ // illegal code
2400
2953
run= 66;
2401
2954
level= MAX_LEVEL;
2429
2982
if (!done) {
2430
2983
done = 1;
2431
2984
2432
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2985
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2433
2986
intra_MCBPC_bits, 1, 1,
2434
intra_MCBPC_code, 1, 1);
2435
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2987
intra_MCBPC_code, 1, 1, 1);
2988
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2436
2989
inter_MCBPC_bits, 1, 1,
2437
inter_MCBPC_code, 1, 1);
2990
inter_MCBPC_code, 1, 1, 1);
2438
2991
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2439
2992
&cbpy_tab[0][1], 2, 1,
2440
&cbpy_tab[0][0], 2, 1);
2993
&cbpy_tab[0][0], 2, 1, 1);
2441
2994
init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2442
2995
&mvtab[0][1], 2, 1,
2443
&mvtab[0][0], 2, 1);
2444
init_rl(&rl_inter);
2445
init_rl(&rl_intra);
2446
init_rl(&rvlc_rl_inter);
2447
init_rl(&rvlc_rl_intra);
2448
init_rl(&rl_intra_aic);
2449
init_vlc_rl(&rl_inter);
2450
init_vlc_rl(&rl_intra);
2451
init_vlc_rl(&rvlc_rl_inter);
2452
init_vlc_rl(&rvlc_rl_intra);
2453
init_vlc_rl(&rl_intra_aic);
2996
&mvtab[0][0], 2, 1, 1);
2997
init_rl(&rl_inter, 1);
2998
init_rl(&rl_intra, 1);
2999
init_rl(&rvlc_rl_inter, 1);
3000
init_rl(&rvlc_rl_intra, 1);
3001
init_rl(&rl_intra_aic, 1);
3002
init_vlc_rl(&rl_inter, 1);
3003
init_vlc_rl(&rl_intra, 1);
3004
init_vlc_rl(&rvlc_rl_inter, 1);
3005
init_vlc_rl(&rvlc_rl_intra, 1);
3006
init_vlc_rl(&rl_intra_aic, 1);
2454
3007
init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2455
3008
&DCtab_lum[0][1], 2, 1,
2456
&DCtab_lum[0][0], 2, 1);
3009
&DCtab_lum[0][0], 2, 1, 1);
2457
3010
init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2458
3011
&DCtab_chrom[0][1], 2, 1,
2459
&DCtab_chrom[0][0], 2, 1);
3012
&DCtab_chrom[0][0], 2, 1, 1);
2460
3013
init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2461
3014
&sprite_trajectory_tab[0][1], 4, 2,
2462
&sprite_trajectory_tab[0][0], 4, 2);
3015
&sprite_trajectory_tab[0][0], 4, 2, 1);
2463
3016
init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2464
3017
&mb_type_b_tab[0][1], 2, 1,
2465
&mb_type_b_tab[0][0], 2, 1);
3018
&mb_type_b_tab[0][0], 2, 1, 1);
3019
init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
3020
&h263_mbtype_b_tab[0][1], 2, 1,
3021
&h263_mbtype_b_tab[0][0], 2, 1, 1);
3022
init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
3023
&cbpc_b_tab[0][1], 2, 1,
3024
&cbpc_b_tab[0][0], 2, 1, 1);
2466
3025
}
2467
3026
}
2468
3027
2478
3037
return 4;
2479
3038
}
2480
3039
3040
int ff_h263_decode_mba(MpegEncContext *s)
3041
{
3042
int i, mb_pos;
3043
3044
for(i=0; i<6; i++){
3045
if(s->mb_num-1 <= ff_mba_max[i]) break;
3046
}
3047
mb_pos= get_bits(&s->gb, ff_mba_length[i]);
3048
s->mb_x= mb_pos % s->mb_width;
3049
s->mb_y= mb_pos / s->mb_width;
3050
3051
return mb_pos;
3052
}
3053
3054
void ff_h263_encode_mba(MpegEncContext *s)
3055
{
3056
int i, mb_pos;
3057
3058
for(i=0; i<6; i++){
3059
if(s->mb_num-1 <= ff_mba_max[i]) break;
3060
}
3061
mb_pos= s->mb_x + s->mb_width*s->mb_y;
3062
put_bits(&s->pb, ff_mba_length[i], mb_pos);
3063
}
3064
2481
3065
/**
2482
* decodes the group of blocks header.
3066
* decodes the group of blocks header or slice header.
2483
3067
* @return <0 if an error occured
2484
3068
*/
2485
3069
static int h263_decode_gob_header(MpegEncContext *s)
2486
3070
{
2487
unsigned int val, gfid;
3071
unsigned int val, gfid, gob_number;
2488
3072
int left;
2489
3073
2490
3074
/* Check for GOB Start Code */
2491
3075
val = show_bits(&s->gb, 16);
2492
3076
if(val)
2499
3083
for(;left>13; left--){
2500
3084
if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
2501
3085
}
2502
if(left<=13)
2503
return -1;
2504
2505
#ifdef DEBUG
2506
fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
2507
#endif
2508
s->gob_number = get_bits(&s->gb, 5); /* GN */
2509
gfid = get_bits(&s->gb, 2); /* GFID */
2510
s->qscale = get_bits(&s->gb, 5); /* GQUANT */
2511
if(s->qscale==0)
2512
return -1;
2513
s->mb_x= 0;
2514
s->mb_y= s->gob_index* s->gob_number;
2515
if(s->mb_y >= s->mb_height)
2516
return -1;
2517
#ifdef DEBUG
2518
fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
2519
#endif
3086
if(left<=13)
3087
return -1;
3088
3089
if(s->h263_slice_structured){
3090
if(get_bits1(&s->gb)==0)
3091
return -1;
3092
3093
ff_h263_decode_mba(s);
3094
3095
if(s->mb_num > 1583)
3096
if(get_bits1(&s->gb)==0)
3097
return -1;
3098
3099
s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3100
if(get_bits1(&s->gb)==0)
3101
return -1;
3102
gfid = get_bits(&s->gb, 2); /* GFID */
3103
}else{
3104
gob_number = get_bits(&s->gb, 5); /* GN */
3105
s->mb_x= 0;
3106
s->mb_y= s->gob_index* gob_number;
3107
gfid = get_bits(&s->gb, 2); /* GFID */
3108
s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3109
}
3110
3111
if(s->mb_y >= s->mb_height)
3112
return -1;
3113
3114
if(s->qscale==0)
3115
return -1;
3116
2520
3117
return 0;
2521
3118
}
2522
3119
2531
3128
2532
3129
void ff_mpeg4_init_partitions(MpegEncContext *s)
2533
3130
{
2534
init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
2535
init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
3131
uint8_t *start= pbBufPtr(&s->pb);
3132
uint8_t *end= s->pb.buf_end;
3133
int size= end - start;
3134
int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3135
int tex_size= (size - 2*pb_size)&(~3);
3136
3137
set_put_bits_buffer_size(&s->pb, pb_size);
3138
init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3139
init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
2536
3140
}
2537
3141
2538
3142
void ff_mpeg4_merge_partitions(MpegEncContext *s)
2539
3143
{
2540
const int pb2_len = get_bit_count(&s->pb2 );
2541
const int tex_pb_len= get_bit_count(&s->tex_pb);
2542
const int bits= get_bit_count(&s->pb);
3144
const int pb2_len = put_bits_count(&s->pb2 );
3145
const int tex_pb_len= put_bits_count(&s->tex_pb);
3146
const int bits= put_bits_count(&s->pb);
2543
3147
2544
3148
if(s->pict_type==I_TYPE){
2545
3149
put_bits(&s->pb, 19, DC_MARKER);
2555
3159
flush_put_bits(&s->pb2);
2556
3160
flush_put_bits(&s->tex_pb);
2557
3161
2558
ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
2559
ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
2560
s->last_bits= get_bit_count(&s->pb);
3162
set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3163
ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3164
ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3165
s->last_bits= put_bits_count(&s->pb);
2561
3166
}
2562
3167
2563
3168
#endif //CONFIG_ENCODERS
2582
3187
{
2583
3188
int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2584
3189
2585
ff_mpeg4_stuffing(&s->pb);
2586
3190
put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
2587
3191
put_bits(&s->pb, 1, 1);
2588
3192
2589
3193
put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
2590
3194
put_bits(&s->pb, s->quant_precision, s->qscale);
2591
3195
put_bits(&s->pb, 1, 0); /* no HEC */
2598
3202
* @return 0 if not
2599
3203
*/
2600
3204
static inline int mpeg4_is_resync(MpegEncContext *s){
2601
const int bits_count= get_bits_count(&s->gb);
2602
3205
int bits_count= get_bits_count(&s->gb);
3206
int v= show_bits(&s->gb, 16);
3207
2603
3208
if(s->workaround_bugs&FF_BUG_NO_PADDING){
2604
3209
return 0;
2605
3210
}
2606
3211
3212
while(v<=0xFF){
3213
if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
3214
break;
3215
skip_bits(&s->gb, 8+s->pict_type);
3216
bits_count+= 8+s->pict_type;
3217
v= show_bits(&s->gb, 16);
3218
}
3219
2607
3220
if(bits_count + 8 >= s->gb.size_in_bits){
2608
int v= show_bits(&s->gb, 8);
3221
v>>=8;
2609
3222
v|= 0x7F >> (7-(bits_count&7));
2610
3223
2611
3224
if(v==0x7F)
2612
3225
return 1;
2613
3226
}else{
2614
if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3227
if(v == ff_mpeg4_resync_prefix[bits_count&7]){
2615
3228
int len;
2616
3229
GetBitContext gb= s->gb;
2617
3230
2618
3231
skip_bits(&s->gb, 1);
2619
3232
align_get_bits(&s->gb);
2620
3233
2621
3234
for(len=0; len<32; len++){
2622
3235
if(get_bits1(&s->gb)) break;
2623
3236
}
2639
3252
{
2640
3253
int mb_num_bits= av_log2(s->mb_num - 1) + 1;
2641
3254
int header_extension=0, mb_num, len;
2642
3255
2643
3256
/* is there enough space left for a video packet + header */
2644
3257
if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
2645
3258
2648
3261
}
2649
3262
2650
3263
if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
2651
printf("marker does not match f_code\n");
3264
av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
2652
3265
return -1;
2653
3266
}
2654
3267
2655
3268
if(s->shape != RECT_SHAPE){
2656
3269
header_extension= get_bits1(&s->gb);
2657
3270
//FIXME more stuff here
2659
3272
2660
3273
mb_num= get_bits(&s->gb, mb_num_bits);
2661
3274
if(mb_num>=s->mb_num){
2662
fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3275
av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
2663
3276
return -1;
2664
3277
}
2665
3278
if(s->pict_type == B_TYPE){
2666
3279
while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
2667
if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
3280
if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
2668
3281
}
2669
3282
2670
3283
s->mb_x= mb_num % s->mb_width;
2671
3284
s->mb_y= mb_num / s->mb_width;
2672
3285
2673
3286
if(s->shape != BIN_ONLY_SHAPE){
2674
int qscale= get_bits(&s->gb, s->quant_precision);
3287
int qscale= get_bits(&s->gb, s->quant_precision);
2675
3288
if(qscale)
2676
s->qscale= qscale;
3289
s->chroma_qscale=s->qscale= qscale;
2677
3290
}
2678
3291
2679
3292
if(s->shape == RECT_SHAPE){
2683
3296
int time_increment;
2684
3297
int time_incr=0;
2685
3298
2686
while (get_bits1(&s->gb) != 0)
3299
while (get_bits1(&s->gb) != 0)
2687
3300
time_incr++;
2688
3301
2689
3302
check_marker(&s->gb, "before time_increment in video packed header");
2690
3303
time_increment= get_bits(&s->gb, s->time_increment_bits);
2691
3304
check_marker(&s->gb, "before vop_coding_type in video packed header");
2692
3305
2693
3306
skip_bits(&s->gb, 2); /* vop coding type */
2694
3307
//FIXME not rect stuff here
2695
3308
2696
3309
if(s->shape != BIN_ONLY_SHAPE){
2697
3310
skip_bits(&s->gb, 3); /* intra dc vlc threshold */
2698
//FIXME dont just ignore everything
3311
//FIXME don't just ignore everything
2699
3312
if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2700
mpeg4_decode_sprite_trajectory(s);
2701
fprintf(stderr, "untested\n");
3313
mpeg4_decode_sprite_trajectory(s, &s->gb);
3314
av_log(s->avctx, AV_LOG_ERROR, "untested\n");
2702
3315
}
2703
3316
2704
3317
//FIXME reduced res stuff here
2705
3318
2706
3319
if (s->pict_type != I_TYPE) {
2707
int f_code = get_bits(&s->gb, 3); /* fcode_for */
3320
int f_code = get_bits(&s->gb, 3); /* fcode_for */
2708
3321
if(f_code==0){
2709
printf("Error, video packet header damaged (f_code=0)\n");
3322
av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
2710
3323
}
2711
3324
}
2712
3325
if (s->pict_type == B_TYPE) {
2713
3326
int b_code = get_bits(&s->gb, 3);
2714
3327
if(b_code==0){
2715
printf("Error, video packet header damaged (b_code=0)\n");
3328
av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
2716
3329
}
2717
}
3330
}
2718
3331
}
2719
3332
}
2720
3333
//FIXME new-pred stuff
2721
3334
2722
3335
//printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
2723
3336
2724
3337
return 0;
2728
3341
{
2729
3342
int c_wrap, c_xy, l_wrap, l_xy;
2730
3343
2731
l_wrap= s->block_wrap[0];
2732
l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
2733
c_wrap= s->block_wrap[4];
2734
c_xy= s->mb_y*c_wrap + s->mb_x;
3344
l_wrap= s->b8_stride;
3345
l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3346
c_wrap= s->mb_stride;
3347
c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
2735
3348
2736
3349
#if 0
2737
3350
/* clean DC */
2746
3359
memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
2747
3360
2748
3361
/* clean MV */
2749
// we cant clear the MVs as they might be needed by a b frame
3362
// we can't clear the MVs as they might be needed by a b frame
2750
3363
// memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
2751
3364
// memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
2752
3365
s->last_mv[0][0][0]=
2761
3374
*/
2762
3375
int ff_h263_resync(MpegEncContext *s){
2763
3376
int left, ret;
2764
2765
if(s->codec_id==CODEC_ID_MPEG4)
3377
3378
if(s->codec_id==CODEC_ID_MPEG4){
2766
3379
skip_bits1(&s->gb);
2767
2768
align_get_bits(&s->gb);
3380
align_get_bits(&s->gb);
3381
}
2769
3382
2770
3383
if(show_bits(&s->gb, 16)==0){
2771
3384
if(s->codec_id==CODEC_ID_MPEG4)
2775
3388
if(ret>=0)
2776
3389
return 0;
2777
3390
}
2778
//ok, its not where its supposed to be ...
3391
//ok, it's not where its supposed to be ...
2779
3392
s->gb= s->last_resync_gb;
2780
3393
align_get_bits(&s->gb);
2781
3394
left= s->gb.size_in_bits - get_bits_count(&s->gb);
2782
2783
for(;left>16+1+5+5; left-=8){
3395
3396
for(;left>16+1+5+5; left-=8){
2784
3397
if(show_bits(&s->gb, 16)==0){
2785
3398
GetBitContext bak= s->gb;
2786
3399
2795
3408
}
2796
3409
skip_bits(&s->gb, 8);
2797
3410
}
2798
3411
2799
3412
return -1;
2800
3413
}
2801
3414
2809
3422
int len = 1 << (s->f_code + 4);
2810
3423
const int a= s->sprite_warping_accuracy;
2811
3424
3425
if(s->workaround_bugs & FF_BUG_AMV)
3426
len >>= s->quarter_sample;
3427
2812
3428
if(s->real_sprite_warping_points==1){
2813
3429
if(s->divx_version==500 && s->divx_build==413)
2814
3430
sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
2825
3441
sum=0;
2826
3442
for(y=0; y<16; y++){
2827
3443
int v;
2828
3444
2829
3445
v= mb_v + dy*y;
2830
3446
//XXX FIXME optimize
2831
3447
for(x=0; x<16; x++){
2849
3465
static int mpeg4_decode_partition_a(MpegEncContext *s){
2850
3466
int mb_num;
2851
3467
static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
2852
3468
2853
3469
/* decode first partition */
2854
3470
mb_num=0;
2855
3471
s->first_slice_line=1;
2859
3475
const int xy= s->mb_x + s->mb_y*s->mb_stride;
2860
3476
int cbpc;
2861
3477
int dir=0;
2862
3478
2863
3479
mb_num++;
2864
3480
ff_update_block_index(s);
2865
3481
if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2866
3482
s->first_slice_line=0;
2867
3483
2868
3484
if(s->pict_type==I_TYPE){
2869
3485
int i;
2870
3486
2871
if(show_bits_long(&s->gb, 19)==DC_MARKER){
2872
return mb_num-1;
2873
}
2874
2875
3487
do{
3488
if(show_bits_long(&s->gb, 19)==DC_MARKER){
3489
return mb_num-1;
3490
}
3491
2876
3492
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
2877
3493
if (cbpc < 0){
2878
fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3494
av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2879
3495
return -1;
2880
3496
}
2881
3497
}while(cbpc == 8);
2885
3501
s->mb_intra = 1;
2886
3502
2887
3503
if(cbpc & 4) {
2888
change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3504
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
2889
3505
}
2890
3506
s->current_picture.qscale_table[xy]= s->qscale;
2891
3507
2892
3508
s->mbintra_table[xy]= 1;
2893
3509
for(i=0; i<6; i++){
2894
3510
int dc_pred_dir;
2895
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3511
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2896
3512
if(dc < 0){
2897
fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3513
av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2898
3514
return -1;
2899
3515
}
2900
3516
dir<<=1;
2903
3519
s->pred_dir_table[xy]= dir;
2904
3520
}else{ /* P/S_TYPE */
2905
3521
int mx, my, pred_x, pred_y, bits;
2906
int16_t * const mot_val= s->motion_val[s->block_index[0]];
2907
const int stride= s->block_wrap[0]*2;
3522
int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3523
const int stride= s->b8_stride*2;
2908
3524
2909
// do{ //FIXME
3525
try_again:
2910
3526
bits= show_bits(&s->gb, 17);
2911
3527
if(bits==MOTION_MARKER){
2912
3528
return mb_num-1;
2934
3550
2935
3551
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
2936
3552
if (cbpc < 0){
2937
fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3553
av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2938
3554
return -1;
2939
3555
}
2940
// }while(cbpc == 20);
3556
if(cbpc == 20)
3557
goto try_again;
2941
3558
2942
3559
s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2943
3560
2944
3561
s->mb_intra = ((cbpc & 4) != 0);
2945
3562
2946
3563
if(s->mb_intra){
2947
3564
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
2948
3565
s->mbintra_table[xy]= 1;
2949
mot_val[0 ]= mot_val[2 ]=
3566
mot_val[0 ]= mot_val[2 ]=
2950
3567
mot_val[0+stride]= mot_val[2+stride]= 0;
2951
3568
mot_val[1 ]= mot_val[3 ]=
2952
3569
mot_val[1+stride]= mot_val[3+stride]= 0;
2957
3574
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2958
3575
s->mcsel= get_bits1(&s->gb);
2959
3576
else s->mcsel= 0;
2960
3577
2961
3578
if ((cbpc & 16) == 0) {
2962
3579
/* 16x16 motion prediction */
2963
3580
2964
h263_pred_motion(s, 0, &pred_x, &pred_y);
3581
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2965
3582
if(!s->mcsel){
2966
3583
mx = h263_decode_motion(s, pred_x, s->f_code);
2967
3584
if (mx >= 0xffff)
2985
3602
int i;
2986
3603
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
2987
3604
for(i=0;i<4;i++) {
2988
int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
3605
int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
2989
3606
mx = h263_decode_motion(s, pred_x, s->f_code);
2990
3607
if (mx >= 0xffff)
2991
3608
return -1;
2992
3609
2993
3610
my = h263_decode_motion(s, pred_y, s->f_code);
2994
3611
if (my >= 0xffff)
2995
3612
return -1;
3025
3642
ff_update_block_index(s);
3026
3643
if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3027
3644
s->first_slice_line=0;
3028
3645
3029
3646
if(s->pict_type==I_TYPE){
3030
3647
int ac_pred= get_bits1(&s->gb);
3031
3648
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3032
3649
if(cbpy<0){
3033
fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3650
av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3034
3651
return -1;
3035
3652
}
3036
3653
3037
3654
s->cbp_table[xy]|= cbpy<<2;
3038
s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3655
s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3039
3656
}else{ /* P || S_TYPE */
3040
if(IS_INTRA(s->current_picture.mb_type[xy])){
3657
if(IS_INTRA(s->current_picture.mb_type[xy])){
3041
3658
int dir=0,i;
3042
3659
int ac_pred = get_bits1(&s->gb);
3043
3660
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3044
3661
3045
3662
if(cbpy<0){
3046
fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3663
av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3047
3664
return -1;
3048
3665
}
3049
3666
3050
3667
if(s->cbp_table[xy] & 8) {
3051
change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3668
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3052
3669
}
3053
3670
s->current_picture.qscale_table[xy]= s->qscale;
3054
3671
3055
3672
for(i=0; i<6; i++){
3056
3673
int dc_pred_dir;
3057
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3674
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3058
3675
if(dc < 0){
3059
fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3676
av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3060
3677
return -1;
3061
3678
}
3062
3679
dir<<=1;
3064
3681
}
3065
3682
s->cbp_table[xy]&= 3; //remove dquant
3066
3683
s->cbp_table[xy]|= cbpy<<2;
3067
s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3684
s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3068
3685
s->pred_dir_table[xy]= dir;
3069
3686
}else if(IS_SKIP(s->current_picture.mb_type[xy])){
3070
3687
s->current_picture.qscale_table[xy]= s->qscale;
3073
3690
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3074
3691
3075
3692
if(cbpy<0){
3076
fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3693
av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3077
3694
return -1;
3078
3695
}
3079
3696
3080
3697
if(s->cbp_table[xy] & 8) {
3081
change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
3698
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3082
3699
}
3083
3700
s->current_picture.qscale_table[xy]= s->qscale;
3084
3701
3102
3719
int mb_num;
3103
3720
const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3104
3721
const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3105
3106
mb_num= mpeg4_decode_partition_a(s);
3722
3723
mb_num= mpeg4_decode_partition_a(s);
3107
3724
if(mb_num<0){
3108
3725
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3109
3726
return -1;
3110
3727
}
3111
3728
3112
3729
if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3113
fprintf(stderr, "slice below monitor ...\n");
3730
av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3114
3731
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3115
3732
return -1;
3116
3733
}
3117
3734
3118
3735
s->mb_num_left= mb_num;
3119
3736
3120
3737
if(s->pict_type==I_TYPE){
3738
while(show_bits(&s->gb, 9) == 1)
3739
skip_bits(&s->gb, 9);
3121
3740
if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3122
fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3741
av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3123
3742
return -1;
3124
3743
}
3125
3744
}else{
3745
while(show_bits(&s->gb, 10) == 1)
3746
skip_bits(&s->gb, 10);
3126
3747
if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3127
fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3748
av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3128
3749
return -1;
3129
3750
}
3130
3751
}
3131
3752
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3132
3753
3133
3754
if( mpeg4_decode_partition_b(s, mb_num) < 0){
3134
3755
if(s->pict_type==P_TYPE)
3135
3756
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3139
3760
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3140
3761
}
3141
3762
3142
return 0;
3763
return 0;
3143
3764
}
3144
3765
3145
3766
/**
3154
3775
mb_type= s->current_picture.mb_type[xy];
3155
3776
cbp = s->cbp_table[xy];
3156
3777
3778
s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
3779
3157
3780
if(s->current_picture.qscale_table[xy] != s->qscale){
3158
s->qscale= s->current_picture.qscale_table[xy];
3159
s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3160
s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3781
ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3161
3782
}
3162
3783
3163
3784
if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3164
3785
int i;
3165
3786
for(i=0; i<4; i++){
3166
s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
3167
s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
3787
s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3788
s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3168
3789
}
3169
3790
s->mb_intra = IS_INTRA(mb_type);
3170
3791
3176
3797
s->mv_type = MV_TYPE_16X16;
3177
3798
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3178
3799
s->mcsel=1;
3179
s->mb_skiped = 0;
3800
s->mb_skipped = 0;
3180
3801
}else{
3181
3802
s->mcsel=0;
3182
s->mb_skiped = 1;
3803
s->mb_skipped = 1;
3183
3804
}
3184
3805
}else if(s->mb_intra){
3185
3806
s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3186
3807
}else if(!s->mb_intra){
3187
3808
// s->mcsel= 0; //FIXME do we need to init that
3188
3809
3189
3810
s->mv_dir = MV_DIR_FORWARD;
3190
3811
if (IS_8X8(mb_type)) {
3191
3812
s->mv_type = MV_TYPE_8X8;
3200
3821
3201
3822
if (!IS_SKIP(mb_type)) {
3202
3823
int i;
3824
s->dsp.clear_blocks(s->block[0]);
3203
3825
/* decode each block */
3204
3826
for (i = 0; i < 6; i++) {
3205
3827
if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3206
fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3828
av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3207
3829
return -1;
3208
3830
}
3209
3831
cbp+=cbp;
3217
3839
if(mpeg4_is_resync(s))
3218
3840
return SLICE_END;
3219
3841
else
3220
return SLICE_NOEND;
3842
return SLICE_NOEND;
3221
3843
}else{
3222
3844
if(mpeg4_is_resync(s)){
3223
3845
const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3228
3850
}
3229
3851
}
3230
3852
3853
/**
3854
* read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3855
*/
3856
static void preview_obmc(MpegEncContext *s){
3857
GetBitContext gb= s->gb;
3858
3859
int cbpc, i, pred_x, pred_y, mx, my;
3860
int16_t *mot_val;
3861
const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3862
const int stride= s->b8_stride*2;
3863
3864
for(i=0; i<4; i++)
3865
s->block_index[i]+= 2;
3866
for(i=4; i<6; i++)
3867
s->block_index[i]+= 1;
3868
s->mb_x++;
3869
3870
assert(s->pict_type == P_TYPE);
3871
3872
do{
3873
if (get_bits1(&s->gb)) {
3874
/* skip mb */
3875
mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3876
mot_val[0 ]= mot_val[2 ]=
3877
mot_val[0+stride]= mot_val[2+stride]= 0;
3878
mot_val[1 ]= mot_val[3 ]=
3879
mot_val[1+stride]= mot_val[3+stride]= 0;
3880
3881
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3882
goto end;
3883
}
3884
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3885
}while(cbpc == 20);
3886
3887
if(cbpc & 4){
3888
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3889
}else{
3890
get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3891
if (cbpc & 8) {
3892
if(s->modified_quant){
3893
if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3894
else skip_bits(&s->gb, 5);
3895
}else
3896
skip_bits(&s->gb, 2);
3897
}
3898
3899
if ((cbpc & 16) == 0) {
3900
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3901
/* 16x16 motion prediction */
3902
mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3903
if (s->umvplus)
3904
mx = h263p_decode_umotion(s, pred_x);
3905
else
3906
mx = h263_decode_motion(s, pred_x, 1);
3907
3908
if (s->umvplus)
3909
my = h263p_decode_umotion(s, pred_y);
3910
else
3911
my = h263_decode_motion(s, pred_y, 1);
3912
3913
mot_val[0 ]= mot_val[2 ]=
3914
mot_val[0+stride]= mot_val[2+stride]= mx;
3915
mot_val[1 ]= mot_val[3 ]=
3916
mot_val[1+stride]= mot_val[3+stride]= my;
3917
} else {
3918
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3919
for(i=0;i<4;i++) {
3920
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3921
if (s->umvplus)
3922
mx = h263p_decode_umotion(s, pred_x);
3923
else
3924
mx = h263_decode_motion(s, pred_x, 1);
3925
3926
if (s->umvplus)
3927
my = h263p_decode_umotion(s, pred_y);
3928
else
3929
my = h263_decode_motion(s, pred_y, 1);
3930
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3931
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3932
mot_val[0] = mx;
3933
mot_val[1] = my;
3934
}
3935
}
3936
}
3937
end:
3938
3939
for(i=0; i<4; i++)
3940
s->block_index[i]-= 2;
3941
for(i=4; i<6; i++)
3942
s->block_index[i]-= 1;
3943
s->mb_x--;
3944
3945
s->gb= gb;
3946
}
3947
3948
static void h263_decode_dquant(MpegEncContext *s){
3949
static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3950
3951
if(s->modified_quant){
3952
if(get_bits1(&s->gb))
3953
s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3954
else
3955
s->qscale= get_bits(&s->gb, 5);
3956
}else
3957
s->qscale += quant_tab[get_bits(&s->gb, 2)];
3958
ff_set_qscale(s, s->qscale);
3959
}
3960
3231
3961
int ff_h263_decode_mb(MpegEncContext *s,
3232
3962
DCTELEM block[6][64])
3233
3963
{
3234
3964
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3235
3965
int16_t *mot_val;
3236
static int8_t quant_tab[4] = { -1, -2, 1, 2 };
3237
3966
const int xy= s->mb_x + s->mb_y * s->mb_stride;
3238
3967
3239
if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3240
do{
3241
if (get_bits1(&s->gb)) {
3242
/* skip mb */
3243
s->mb_intra = 0;
3244
for(i=0;i<6;i++)
3245
s->block_last_index[i] = -1;
3246
s->mv_dir = MV_DIR_FORWARD;
3247
s->mv_type = MV_TYPE_16X16;
3248
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3249
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
3250
s->mcsel=1;
3251
s->mv[0][0][0]= get_amv(s, 0);
3252
s->mv[0][0][1]= get_amv(s, 1);
3968
assert(!s->h263_pred);
3253
3969
3254
s->mb_skiped = 0;
3255
}else{
3970
if (s->pict_type == P_TYPE) {
3971
do{
3972
if (get_bits1(&s->gb)) {
3973
/* skip mb */
3974
s->mb_intra = 0;
3975
for(i=0;i<6;i++)
3976
s->block_last_index[i] = -1;
3977
s->mv_dir = MV_DIR_FORWARD;
3978
s->mv_type = MV_TYPE_16X16;
3256
3979
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3257
s->mcsel=0;
3258
3980
s->mv[0][0][0] = 0;
3259
3981
s->mv[0][0][1] = 0;
3260
s->mb_skiped = 1;
3261
}
3262
goto end;
3263
}
3264
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3265
//fprintf(stderr, "\tCBPC: %d", cbpc);
3266
if (cbpc < 0){
3267
fprintf(stderr, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3982
s->mb_skipped = !(s->obmc | s->loop_filter);
3983
goto end;
3984
}
3985
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3986
//fprintf(stderr, "\tCBPC: %d", cbpc);
3987
if (cbpc < 0){
3988
av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3989
return -1;
3990
}
3991
}while(cbpc == 20);
3992
3993
s->dsp.clear_blocks(s->block[0]);
3994
3995
dquant = cbpc & 8;
3996
s->mb_intra = ((cbpc & 4) != 0);
3997
if (s->mb_intra) goto intra;
3998
3999
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4000
4001
if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4002
cbpy ^= 0xF;
4003
4004
cbp = (cbpc & 3) | (cbpy << 2);
4005
if (dquant) {
4006
h263_decode_dquant(s);
4007
}
4008
4009
s->mv_dir = MV_DIR_FORWARD;
4010
if ((cbpc & 16) == 0) {
4011
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4012
/* 16x16 motion prediction */
4013
s->mv_type = MV_TYPE_16X16;
4014
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4015
if (s->umvplus)
4016
mx = h263p_decode_umotion(s, pred_x);
4017
else
4018
mx = h263_decode_motion(s, pred_x, 1);
4019
4020
if (mx >= 0xffff)
4021
return -1;
4022
4023
if (s->umvplus)
4024
my = h263p_decode_umotion(s, pred_y);
4025
else
4026
my = h263_decode_motion(s, pred_y, 1);
4027
4028
if (my >= 0xffff)
4029
return -1;
4030
s->mv[0][0][0] = mx;
4031
s->mv[0][0][1] = my;
4032
4033
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4034
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4035
} else {
4036
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4037
s->mv_type = MV_TYPE_8X8;
4038
for(i=0;i<4;i++) {
4039
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4040
if (s->umvplus)
4041
mx = h263p_decode_umotion(s, pred_x);
4042
else
4043
mx = h263_decode_motion(s, pred_x, 1);
4044
if (mx >= 0xffff)
4045
return -1;
4046
4047
if (s->umvplus)
4048
my = h263p_decode_umotion(s, pred_y);
4049
else
4050
my = h263_decode_motion(s, pred_y, 1);
4051
if (my >= 0xffff)
4052
return -1;
4053
s->mv[0][i][0] = mx;
4054
s->mv[0][i][1] = my;
4055
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
4056
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
4057
mot_val[0] = mx;
4058
mot_val[1] = my;
4059
}
4060
}
4061
4062
/* decode each block */
4063
for (i = 0; i < 6; i++) {
4064
if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4065
return -1;
4066
cbp+=cbp;
4067
}
4068
4069
if(s->obmc){
4070
if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4071
preview_obmc(s);
4072
}
4073
} else if(s->pict_type==B_TYPE) {
4074
int mb_type;
4075
const int stride= s->b8_stride;
4076
int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4077
int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4078
// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4079
4080
//FIXME ugly
4081
mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4082
mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4083
mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4084
mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4085
4086
do{
4087
mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4088
if (mb_type < 0){
4089
av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4090
return -1;
4091
}
4092
4093
mb_type= h263_mb_type_b_map[ mb_type ];
4094
}while(!mb_type);
4095
4096
s->mb_intra = IS_INTRA(mb_type);
4097
if(HAS_CBP(mb_type)){
4098
s->dsp.clear_blocks(s->block[0]);
4099
cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4100
if(s->mb_intra){
4101
dquant = IS_QUANT(mb_type);
4102
goto intra;
4103
}
4104
4105
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4106
4107
if (cbpy < 0){
4108
av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4109
return -1;
4110
}
4111
4112
if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4113
cbpy ^= 0xF;
4114
4115
cbp = (cbpc & 3) | (cbpy << 2);
4116
}else
4117
cbp=0;
4118
4119
assert(!s->mb_intra);
4120
4121
if(IS_QUANT(mb_type)){
4122
h263_decode_dquant(s);
4123
}
4124
4125
if(IS_DIRECT(mb_type)){
4126
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4127
mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4128
}else{
4129
s->mv_dir = 0;
4130
s->mv_type= MV_TYPE_16X16;
4131
//FIXME UMV
4132
4133
if(USES_LIST(mb_type, 0)){
4134
int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4135
s->mv_dir = MV_DIR_FORWARD;
4136
4137
mx = h263_decode_motion(s, mx, 1);
4138
my = h263_decode_motion(s, my, 1);
4139
4140
s->mv[0][0][0] = mx;
4141
s->mv[0][0][1] = my;
4142
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4143
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4144
}
4145
4146
if(USES_LIST(mb_type, 1)){
4147
int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4148
s->mv_dir |= MV_DIR_BACKWARD;
4149
4150
mx = h263_decode_motion(s, mx, 1);
4151
my = h263_decode_motion(s, my, 1);
4152
4153
s->mv[1][0][0] = mx;
4154
s->mv[1][0][1] = my;
4155
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4156
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4157
}
4158
}
4159
4160
s->current_picture.mb_type[xy]= mb_type;
4161
4162
/* decode each block */
4163
for (i = 0; i < 6; i++) {
4164
if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4165
return -1;
4166
cbp+=cbp;
4167
}
4168
} else { /* I-Frame */
4169
do{
4170
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4171
if (cbpc < 0){
4172
av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4173
return -1;
4174
}
4175
}while(cbpc == 8);
4176
4177
s->dsp.clear_blocks(s->block[0]);
4178
4179
dquant = cbpc & 4;
4180
s->mb_intra = 1;
4181
intra:
4182
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4183
if (s->h263_aic) {
4184
s->ac_pred = get_bits1(&s->gb);
4185
if(s->ac_pred){
4186
s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4187
4188
s->h263_aic_dir = get_bits1(&s->gb);
4189
}
4190
}else
4191
s->ac_pred = 0;
4192
4193
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4194
if(cbpy<0){
4195
av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3268
4196
return -1;
3269
4197
}
3270
}while(cbpc == 20);
3271
4198
cbp = (cbpc & 3) | (cbpy << 2);
4199
if (dquant) {
4200
h263_decode_dquant(s);
4201
}
4202
4203
/* decode each block */
4204
for (i = 0; i < 6; i++) {
4205
if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4206
return -1;
4207
cbp+=cbp;
4208
}
4209
}
4210
end:
4211
4212
/* per-MB end of slice check */
4213
{
4214
int v= show_bits(&s->gb, 16);
4215
4216
if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4217
v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4218
}
4219
4220
if(v==0)
4221
return SLICE_END;
4222
}
4223
4224
return SLICE_OK;
4225
}
4226
4227
int ff_mpeg4_decode_mb(MpegEncContext *s,
4228
DCTELEM block[6][64])
4229
{
4230
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4231
int16_t *mot_val;
4232
static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4233
const int xy= s->mb_x + s->mb_y * s->mb_stride;
4234
4235
assert(s->h263_pred);
4236
4237
if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4238
do{
4239
if (get_bits1(&s->gb)) {
4240
/* skip mb */
4241
s->mb_intra = 0;
4242
for(i=0;i<6;i++)
4243
s->block_last_index[i] = -1;
4244
s->mv_dir = MV_DIR_FORWARD;
4245
s->mv_type = MV_TYPE_16X16;
4246
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4247
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4248
s->mcsel=1;
4249
s->mv[0][0][0]= get_amv(s, 0);
4250
s->mv[0][0][1]= get_amv(s, 1);
4251
4252
s->mb_skipped = 0;
4253
}else{
4254
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4255
s->mcsel=0;
4256
s->mv[0][0][0] = 0;
4257
s->mv[0][0][1] = 0;
4258
s->mb_skipped = 1;
4259
}
4260
goto end;
4261
}
4262
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4263
//fprintf(stderr, "\tCBPC: %d", cbpc);
4264
if (cbpc < 0){
4265
av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4266
return -1;
4267
}
4268
}while(cbpc == 20);
4269
4270
s->dsp.clear_blocks(s->block[0]);
3272
4271
dquant = cbpc & 8;
3273
4272
s->mb_intra = ((cbpc & 4) != 0);
3274
4273
if (s->mb_intra) goto intra;
3275
4274
3276
4275
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3277
4276
s->mcsel= get_bits1(&s->gb);
3278
4277
else s->mcsel= 0;
3279
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3280
cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
4278
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4279
4280
cbp = (cbpc & 3) | (cbpy << 2);
3281
4281
if (dquant) {
3282
change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
4282
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3283
4283
}
3284
4284
if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
3285
4285
s->interlaced_dct= get_bits1(&s->gb);
3286
4286
3287
4287
s->mv_dir = MV_DIR_FORWARD;
3288
4288
if ((cbpc & 16) == 0) {
3289
4289
if(s->mcsel){
3295
4295
s->mv[0][0][0] = mx;
3296
4296
s->mv[0][0][1] = my;
3297
4297
}else if((!s->progressive_sequence) && get_bits1(&s->gb)){
3298
s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4298
s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
3299
4299
/* 16x8 field motion prediction */
3300
4300
s->mv_type= MV_TYPE_FIELD;
3301
4301
3302
4302
s->field_select[0][0]= get_bits1(&s->gb);
3303
4303
s->field_select[0][1]= get_bits1(&s->gb);
3304
4304
3305
h263_pred_motion(s, 0, &pred_x, &pred_y);
3306
4305
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4306
3307
4307
for(i=0; i<2; i++){
3308
4308
mx = h263_decode_motion(s, pred_x, s->f_code);
3309
4309
if (mx >= 0xffff)
3310
4310
return -1;
3311
4311
3312
4312
my = h263_decode_motion(s, pred_y/2, s->f_code);
3313
4313
if (my >= 0xffff)
3314
4314
return -1;
3317
4317
s->mv[0][i][1] = my;
3318
4318
}
3319
4319
}else{
3320
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4320
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3321
4321
/* 16x16 motion prediction */
3322
4322
s->mv_type = MV_TYPE_16X16;
3323
h263_pred_motion(s, 0, &pred_x, &pred_y);
3324
if (s->umvplus)
3325
mx = h263p_decode_umotion(s, pred_x);
3326
else
3327
mx = h263_decode_motion(s, pred_x, s->f_code);
3328
4323
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4324
mx = h263_decode_motion(s, pred_x, s->f_code);
4325
3329
4326
if (mx >= 0xffff)
3330
4327
return -1;
3331
3332
if (s->umvplus)
3333
my = h263p_decode_umotion(s, pred_y);
3334
else
3335
my = h263_decode_motion(s, pred_y, s->f_code);
3336
4328
4329
my = h263_decode_motion(s, pred_y, s->f_code);
4330
3337
4331
if (my >= 0xffff)
3338
4332
return -1;
3339
4333
s->mv[0][0][0] = mx;
3340
4334
s->mv[0][0][1] = my;
3341
3342
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3343
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3344
4335
}
3345
4336
} else {
3346
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4337
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3347
4338
s->mv_type = MV_TYPE_8X8;
3348
4339
for(i=0;i<4;i++) {
3349
mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
3350
if (s->umvplus)
3351
mx = h263p_decode_umotion(s, pred_x);
3352
else
3353
mx = h263_decode_motion(s, pred_x, s->f_code);
4340
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4341
mx = h263_decode_motion(s, pred_x, s->f_code);
3354
4342
if (mx >= 0xffff)
3355
4343
return -1;
3356
3357
if (s->umvplus)
3358
my = h263p_decode_umotion(s, pred_y);
3359
else
3360
my = h263_decode_motion(s, pred_y, s->f_code);
4344
4345
my = h263_decode_motion(s, pred_y, s->f_code);
3361
4346
if (my >= 0xffff)
3362
4347
return -1;
3363
4348
s->mv[0][i][0] = mx;
3364
4349
s->mv[0][i][1] = my;
3365
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3366
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3367
4350
mot_val[0] = mx;
3368
4351
mot_val[1] = my;
3369
4352
}
3378
4361
3379
4362
if(s->mb_x==0){
3380
4363
for(i=0; i<2; i++){
3381
s->last_mv[i][0][0]=
3382
s->last_mv[i][0][1]=
3383
s->last_mv[i][1][0]=
4364
s->last_mv[i][0][0]=
4365
s->last_mv[i][0][1]=
4366
s->last_mv[i][1][0]=
3384
4367
s->last_mv[i][1][1]= 0;
3385
4368
}
3386
4369
}
3387
4370
3388
4371
/* if we skipped it in the future P Frame than skip it now too */
3389
s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4372
s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
3390
4373
3391
if(s->mb_skiped){
4374
if(s->mb_skipped){
3392
4375
/* skip mb */
3393
4376
for(i=0;i<6;i++)
3394
4377
s->block_last_index[i] = -1;
3399
4382
s->mv[0][0][1] = 0;
3400
4383
s->mv[1][0][0] = 0;
3401
4384
s->mv[1][0][1] = 0;
3402
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4385
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3403
4386
goto end;
3404
4387
}
3405
4388
3406
modb1= get_bits1(&s->gb);
4389
modb1= get_bits1(&s->gb);
3407
4390
if(modb1){
3408
4391
mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
3409
4392
cbp=0;
3411
4394
modb2= get_bits1(&s->gb);
3412
4395
mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
3413
4396
if(mb_type<0){
3414
printf("illegal MB_type\n");
4397
av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
3415
4398
return -1;
3416
4399
}
3417
4400
mb_type= mb_type_b_map[ mb_type ];
3418
4401
if(modb2) cbp= 0;
3419
else cbp= get_bits(&s->gb, 6);
4402
else{
4403
s->dsp.clear_blocks(s->block[0]);
4404
cbp= get_bits(&s->gb, 6);
4405
}
3420
4406
3421
4407
if ((!IS_DIRECT(mb_type)) && cbp) {
3422
4408
if(get_bits1(&s->gb)){
3423
change_qscale(s, get_bits1(&s->gb)*4 - 2);
4409
ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
3424
4410
}
3425
4411
}
3426
4412
3455
4441
s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
3456
4442
s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
3457
4443
}
3458
4444
3459
4445
if(USES_LIST(mb_type, 1)){
3460
4446
s->mv_dir |= MV_DIR_BACKWARD;
3461
4447
3469
4455
3470
4456
if(USES_LIST(mb_type, 0)){
3471
4457
s->mv_dir = MV_DIR_FORWARD;
3472
4458
3473
4459
for(i=0; i<2; i++){
3474
4460
mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
3475
4461
my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
3477
4463
s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
3478
4464
}
3479
4465
}
3480
4466
3481
4467
if(USES_LIST(mb_type, 1)){
3482
4468
s->mv_dir |= MV_DIR_BACKWARD;
3483
4469
3490
4476
}
3491
4477
}
3492
4478
}
3493
4479
3494
4480
if(IS_DIRECT(mb_type)){
3495
4481
if(IS_SKIP(mb_type))
3496
4482
mx=my=0;
3498
4484
mx = h263_decode_motion(s, 0, 1);
3499
4485
my = h263_decode_motion(s, 0, 1);
3500
4486
}
3501
4487
3502
4488
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3503
4489
mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
3504
4490
}
3507
4493
do{
3508
4494
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3509
4495
if (cbpc < 0){
3510
fprintf(stderr, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4496
av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3511
4497
return -1;
3512
4498
}
3513
4499
}while(cbpc == 8);
3515
4501
dquant = cbpc & 4;
3516
4502
s->mb_intra = 1;
3517
4503
intra:
3518
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3519
if (s->h263_pred || s->h263_aic) {
3520
s->ac_pred = get_bits1(&s->gb);
3521
if(s->ac_pred){
3522
s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
3523
3524
if (s->h263_aic)
3525
s->h263_aic_dir = get_bits1(&s->gb);
3526
}
3527
}else
3528
s->ac_pred = 0;
3529
4504
s->ac_pred = get_bits1(&s->gb);
4505
if(s->ac_pred)
4506
s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4507
else
4508
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4509
3530
4510
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3531
4511
if(cbpy<0){
3532
fprintf(stderr, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4512
av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
3533
4513
return -1;
3534
4514
}
3535
4515
cbp = (cbpc & 3) | (cbpy << 2);
4516
4517
s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
4518
3536
4519
if (dquant) {
3537
change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
4520
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3538
4521
}
3539
4522
3540
4523
if(!s->progressive_sequence)
3541
4524
s->interlaced_dct= get_bits1(&s->gb);
3542
4525
4526
s->dsp.clear_blocks(s->block[0]);
3543
4527
/* decode each block */
3544
if (s->h263_pred) {
3545
for (i = 0; i < 6; i++) {
3546
if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
3547
return -1;
3548
cbp+=cbp;
3549
}
3550
} else {
3551
for (i = 0; i < 6; i++) {
3552
if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3553
return -1;
3554
cbp+=cbp;
3555
}
4528
for (i = 0; i < 6; i++) {
4529
if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4530
return -1;
4531
cbp+=cbp;
3556
4532
}
3557
4533
goto end;
3558
4534
}
3559
4535
3560
4536
/* decode each block */
3561
if (s->h263_pred) {
3562
for (i = 0; i < 6; i++) {
3563
if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
3564
return -1;
3565
cbp+=cbp;
3566
}
3567
} else {
3568
for (i = 0; i < 6; i++) {
3569
if (h263_decode_block(s, block[i], i, cbp&32) < 0)
3570
return -1;
3571
cbp+=cbp;
3572
}
4537
for (i = 0; i < 6; i++) {
4538
if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4539
return -1;
4540
cbp+=cbp;
3573
4541
}
3574
4542
end:
3575
4543
3581
4549
return SLICE_OK;
3582
4550
return SLICE_END;
3583
4551
}
3584
}else{
3585
int v= show_bits(&s->gb, 16);
3586
3587
if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
3588
v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
3589
}
3590
3591
if(v==0)
3592
return SLICE_END;
3593
4552
}
3594
4553
3595
return SLICE_OK;
4554
return SLICE_OK;
3596
4555
}
3597
4556
3598
4557
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
3619
4578
3620
4579
/* modulo decoding */
3621
4580
if (!s->h263_long_vectors) {
3622
l = 1 << (f_code + 4);
3623
val = ((val + l)&(l*2-1)) - l;
4581
l = INT_BIT - 5 - f_code;
4582
val = (val<<l)>>l;
3624
4583
} else {
3625
4584
/* horrible h263 long vector mode */
3626
4585
if (pred < -31 && val < -63)
3627
4586
val += 64;
3628
4587
if (pred > 32 && val > 63)
3629
4588
val -= 64;
3630
4589
3631
4590
}
3632
4591
return val;
3633
4592
}
3636
4595
static int h263p_decode_umotion(MpegEncContext * s, int pred)
3637
4596
{
3638
4597
int code = 0, sign;
3639
4598
3640
4599
if (get_bits1(&s->gb)) /* Motion difference = 0 */
3641
4600
return pred;
3642
4601
3643
4602
code = 2 + get_bits1(&s->gb);
3644
4603
3645
4604
while (get_bits1(&s->gb))
3646
4605
{
3647
4606
code <<= 1;
3649
4608
}
3650
4609
sign = code & 1;
3651
4610
code >>= 1;
3652
4611
3653
4612
code = (sign) ? (pred - code) : (pred + code);
3654
4613
#ifdef DEBUG
3655
fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
4614
av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
3656
4615
#endif
3657
return code;
4616
return code;
3658
4617
3659
4618
}
3660
4619
3664
4623
int code, level, i, j, last, run;
3665
4624
RLTable *rl = &rl_inter;
3666
4625
const uint8_t *scan_table;
4626
GetBitContext gb= s->gb;
3667
4627
3668
4628
scan_table = s->intra_scantable.permutated;
3669
4629
if (s->h263_aic && s->mb_intra) {
3670
4630
rl = &rl_intra_aic;
3671
4631
i = 0;
3672
4632
if (s->ac_pred) {
3673
if (s->h263_aic_dir)
4633
if (s->h263_aic_dir)
3674
4634
scan_table = s->intra_v_scantable.permutated; /* left */
3675
4635
else
3676
4636
scan_table = s->intra_h_scantable.permutated; /* top */
3677
4637
}
3678
4638
} else if (s->mb_intra) {
3679
4639
/* DC coef */
3680
if(s->h263_rv10){
4640
if(s->codec_id == CODEC_ID_RV10){
4641
#ifdef CONFIG_RV10_DECODER
3681
4642
if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
3682
4643
int component, diff;
3683
4644
component = (n <= 3 ? 0 : n - 4 + 1);
3694
4655
}
3695
4656
} else {
3696
4657
level = get_bits(&s->gb, 8);
4658
if (level == 255)
4659
level = 128;
3697
4660
}
4661
#endif
3698
4662
}else{
3699
4663
level = get_bits(&s->gb, 8);
3700
4664
if((level&0x7F) == 0){
3701
fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
3702
return -1;
4665
av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4666
if(s->error_resilience >= FF_ER_COMPLIANT)
4667
return -1;
3703
4668
}
3704
4669
if (level == 255)
3705
4670
level = 128;
3715
4680
s->block_last_index[n] = i - 1;
3716
4681
return 0;
3717
4682
}
3718
4683
retry:
3719
4684
for(;;) {
3720
4685
code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
3721
4686
if (code < 0){
3722
fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4687
av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
3723
4688
return -1;
3724
4689
}
3725
4690
if (code == rl->n) {
3738
4703
run = get_bits(&s->gb, 6);
3739
4704
level = (int8_t)get_bits(&s->gb, 8);
3740
4705
if(level == -128){
3741
if (s->h263_rv10) {
4706
if (s->codec_id == CODEC_ID_RV10) {
3742
4707
/* XXX: should patch encoder too */
3743
4708
level = get_sbits(&s->gb, 12);
3744
4709
}else{
3756
4721
}
3757
4722
i += run;
3758
4723
if (i >= 64){
3759
fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
4724
if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4725
//looks like a hack but no, it's the way its supposed to work ...
4726
rl = &rl_intra_aic;
4727
i = 0;
4728
s->gb= gb;
4729
memset(block, 0, sizeof(DCTELEM)*64);
4730
goto retry;
4731
}
4732
av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
3760
4733
return -1;
3761
4734
}
3762
4735
j = scan_table[i];
3765
4738
break;
3766
4739
i++;
3767
4740
}
3768
not_coded:
4741
not_coded:
3769
4742
if (s->mb_intra && s->h263_aic) {
3770
4743
h263_pred_acdc(s, block, n);
3771
4744
i = 63;
3782
4755
*/
3783
4756
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
3784
4757
{
3785
int level, pred, code;
3786
uint16_t *dc_val;
4758
int level, code;
3787
4759
3788
if (n < 4)
4760
if (n < 4)
3789
4761
code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
3790
else
4762
else
3791
4763
code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
3792
4764
if (code < 0 || code > 9 /* && s->nbit<9 */){
3793
fprintf(stderr, "illegal dc vlc\n");
4765
av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
3794
4766
return -1;
3795
4767
}
3796
4768
if (code == 0) {
3812
4784
if (code > 8){
3813
4785
if(get_bits1(&s->gb)==0){ /* marker */
3814
4786
if(s->error_resilience>=2){
3815
fprintf(stderr, "dc marker bit missing\n");
4787
av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
3816
4788
return -1;
3817
4789
}
3818
4790
}
3819
4791
}
3820
4792
}
3821
pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
3822
level += pred;
3823
if (level < 0){
3824
if(s->error_resilience>=3){
3825
fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
3826
return -1;
3827
}
3828
level = 0;
3829
}
3830
if (n < 4) {
3831
*dc_val = level * s->y_dc_scale;
3832
} else {
3833
*dc_val = level * s->c_dc_scale;
3834
}
3835
if(IS_3IV1)
3836
*dc_val = level * 8;
3837
3838
if(s->error_resilience>=3){
3839
if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
3840
fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
3841
return -1;
3842
}
3843
}
3844
return level;
4793
4794
return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
3845
4795
}
3846
4796
3847
4797
/**
3859
4809
int qmul, qadd;
3860
4810
3861
4811
//Note intra & rvlc should be optimized away if this is inlined
3862
4812
3863
4813
if(intra) {
3864
/* DC coef */
4814
if(s->use_intra_dc_vlc){
4815
/* DC coef */
3865
4816
if(s->partitioned_frame){
3866
4817
level = s->dc_val[0][ s->block_index[n] ];
3867
4818
if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
3874
4825
}
3875
4826
block[0] = level;
3876
4827
i = 0;
3877
if (!coded)
4828
}else{
4829
i = -1;
4830
ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
4831
}
4832
if (!coded)
3878
4833
goto not_coded;
3879
3880
if(rvlc){
4834
4835
if(rvlc){
3881
4836
rl = &rvlc_rl_intra;
3882
4837
rl_vlc = rvlc_rl_intra.rl_vlc[0];
3883
4838
}else{
3885
4840
rl_vlc = rl_intra.rl_vlc[0];
3886
4841
}
3887
4842
if (s->ac_pred) {
3888
if (dc_pred_dir == 0)
4843
if (dc_pred_dir == 0)
3889
4844
scan_table = s->intra_v_scantable.permutated; /* left */
3890
4845
else
3891
4846
scan_table = s->intra_h_scantable.permutated; /* top */
3902
4857
}
3903
4858
if(rvlc) rl = &rvlc_rl_inter;
3904
4859
else rl = &rl_inter;
3905
4860
3906
4861
scan_table = s->intra_scantable.permutated;
3907
4862
3908
4863
if(s->mpeg_quant){
3909
4864
qmul=1;
3910
4865
qadd=0;
3911
if(rvlc){
3912
rl_vlc = rvlc_rl_inter.rl_vlc[0];
4866
if(rvlc){
4867
rl_vlc = rvlc_rl_inter.rl_vlc[0];
3913
4868
}else{
3914
rl_vlc = rl_inter.rl_vlc[0];
4869
rl_vlc = rl_inter.rl_vlc[0];
3915
4870
}
3916
4871
}else{
3917
4872
qmul = s->qscale << 1;
3918
4873
qadd = (s->qscale - 1) | 1;
3919
if(rvlc){
3920
rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4874
if(rvlc){
4875
rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
3921
4876
}else{
3922
rl_vlc = rl_inter.rl_vlc[s->qscale];
4877
rl_vlc = rl_inter.rl_vlc[s->qscale];
3923
4878
}
3924
4879
}
3925
4880
}
3927
4882
OPEN_READER(re, &s->gb);
3928
4883
for(;;) {
3929
4884
UPDATE_CACHE(re, &s->gb);
3930
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4885
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
3931
4886
if (level==0) {
3932
/* escape */
4887
/* escape */
3933
4888
if(rvlc){
3934
4889
if(SHOW_UBITS(re, &s->gb, 1)==0){
3935
fprintf(stderr, "1. marker bit missing in rvlc esc\n");
4890
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
3936
4891
return -1;
3937
4892
}; SKIP_CACHE(re, &s->gb, 1);
3938
4893
3939
4894
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
3940
4895
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
3941
4896
SKIP_COUNTER(re, &s->gb, 1+1+6);
3942
4897
UPDATE_CACHE(re, &s->gb);
3943
4898
3944
4899
if(SHOW_UBITS(re, &s->gb, 1)==0){
3945
fprintf(stderr, "2. marker bit missing in rvlc esc\n");
4900
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
3946
4901
return -1;
3947
4902
}; SKIP_CACHE(re, &s->gb, 1);
3948
4903
3949
4904
level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
3950
4905
3951
4906
if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
3952
fprintf(stderr, "reverse esc missing\n");
4907
av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
3953
4908
return -1;
3954
4909
}; SKIP_CACHE(re, &s->gb, 5);
3955
4910
3963
4918
int cache;
3964
4919
cache= GET_CACHE(re, &s->gb);
3965
4920
3966
if(IS_3IV1)
4921
if(IS_3IV1)
3967
4922
cache ^= 0xC0000000;
3968
4923
3969
4924
if (cache&0x80000000) {
3979
4934
level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
3980
4935
}else{
3981
4936
if(SHOW_UBITS(re, &s->gb, 1)==0){
3982
fprintf(stderr, "1. marker bit missing in 3. esc\n");
4937
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
3983
4938
return -1;
3984
4939
}; SKIP_CACHE(re, &s->gb, 1);
3985
4940
3986
4941
level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
3987
4942
3988
4943
if(SHOW_UBITS(re, &s->gb, 1)==0){
3989
fprintf(stderr, "2. marker bit missing in 3. esc\n");
4944
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
3990
4945
return -1;
3991
4946
}; LAST_SKIP_CACHE(re, &s->gb, 1);
3992
4947
3993
4948
SKIP_COUNTER(re, &s->gb, 1+12+1);
3994
4949
}
3995
3996
if(level*s->qscale>1024 || level*s->qscale<-1024){
3997
fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
3998
return -1;
3999
}
4000
#if 1
4001
{
4002
const int abs_level= ABS(level);
4003
if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
4950
4951
#if 0
4952
if(s->error_resilience >= FF_ER_COMPLIANT){
4953
const int abs_level= FFABS(level);
4954
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4004
4955
const int run1= run - rl->max_run[last][abs_level] - 1;
4005
4956
if(abs_level <= rl->max_level[last][run]){
4006
fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
4957
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4007
4958
return -1;
4008
4959
}
4009
4960
if(s->error_resilience > FF_ER_COMPLIANT){
4010
4961
if(abs_level <= rl->max_level[last][run]*2){
4011
fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
4962
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4012
4963
return -1;
4013
4964
}
4014
4965
if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4015
fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
4966
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4016
4967
return -1;
4017
4968
}
4018
4969
}
4019
4970
}
4020
4971
}
4021
4972
#endif
4022
if (level>0) level= level * qmul + qadd;
4973
if (level>0) level= level * qmul + qadd;
4023
4974
else level= level * qmul - qadd;
4024
4975
4976
if((unsigned)(level + 2048) > 4095){
4977
if(s->error_resilience > FF_ER_COMPLIANT){
4978
if(level > 2560 || level<-2560){
4979
av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4980
return -1;
4981
}
4982
}
4983
level= level<0 ? -2048 : 2047;
4984
}
4985
4025
4986
i+= run + 1;
4026
4987
if(last) i+=192;
4027
4988
} else {
4032
4993
#else
4033
4994
SKIP_BITS(re, &s->gb, 2);
4034
4995
#endif
4035
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
4996
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4036
4997
i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4037
4998
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4038
4999
LAST_SKIP_BITS(re, &s->gb, 1);
4045
5006
#else
4046
5007
SKIP_BITS(re, &s->gb, 1);
4047
5008
#endif
4048
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
5009
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4049
5010
i+= run;
4050
5011
level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4051
5012
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4060
5021
if (i > 62){
4061
5022
i-= 192;
4062
5023
if(i&(~63)){
4063
fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
5024
av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4064
5025
return -1;
4065
5026
}
4066
5027
4073
5034
CLOSE_READER(re, &s->gb);
4074
5035
}
4075
5036
not_coded:
4076
if (s->mb_intra) {
5037
if (intra) {
5038
if(!s->use_intra_dc_vlc){
5039
block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
5040
5041
i -= i>>31; //if(i == -1) i=0;
5042
}
5043
4077
5044
mpeg4_pred_ac(s, block, n, dc_pred_dir);
4078
5045
if (s->ac_pred) {
4079
5046
i = 63; /* XXX: not optimal */
4088
5055
{
4089
5056
int format, width, height, i;
4090
5057
uint32_t startcode;
4091
5058
4092
5059
align_get_bits(&s->gb);
4093
5060
4094
5061
startcode= get_bits(&s->gb, 22-8);
4095
5062
4096
5063
for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4097
5064
startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4098
5065
4099
5066
if(startcode == 0x20)
4100
5067
break;
4101
5068
}
4102
5069
4103
5070
if (startcode != 0x20) {
4104
fprintf(stderr, "Bad picture start code\n");
5071
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
4105
5072
return -1;
4106
5073
}
4107
5074
/* temporal reference */
4108
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
5075
i = get_bits(&s->gb, 8); /* picture timestamp */
5076
if( (s->picture_number&~0xFF)+i < s->picture_number)
5077
i+= 256;
5078
s->current_picture_ptr->pts=
5079
s->picture_number= (s->picture_number&~0xFF) + i;
4109
5080
4110
/* PTYPE starts here */
5081
/* PTYPE starts here */
4111
5082
if (get_bits1(&s->gb) != 1) {
4112
5083
/* marker */
4113
fprintf(stderr, "Bad marker\n");
5084
av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
4114
5085
return -1;
4115
5086
}
4116
5087
if (get_bits1(&s->gb) != 0) {
4117
fprintf(stderr, "Bad H263 id\n");
4118
return -1; /* h263 id */
5088
av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5089
return -1; /* h263 id */
4119
5090
}
4120
skip_bits1(&s->gb); /* split screen off */
4121
skip_bits1(&s->gb); /* camera off */
4122
skip_bits1(&s->gb); /* freeze picture release off */
5091
skip_bits1(&s->gb); /* split screen off */
5092
skip_bits1(&s->gb); /* camera off */
5093
skip_bits1(&s->gb); /* freeze picture release off */
4123
5094
4124
/* Reset GOB number */
4125
s->gob_number = 0;
4126
4127
5095
format = get_bits(&s->gb, 3);
4128
5096
/*
4129
5097
0 forbidden
4130
5098
1 sub-QCIF
4131
5099
10 QCIF
4132
7 extended PTYPE (PLUSPTYPE)
5100
7 extended PTYPE (PLUSPTYPE)
4133
5101
*/
4134
5102
4135
5103
if (format != 7 && format != 6) {
4139
5107
height = h263_format[format][1];
4140
5108
if (!width)
4141
5109
return -1;
4142
5110
4143
5111
s->pict_type = I_TYPE + get_bits1(&s->gb);
4144
5112
4145
s->unrestricted_mv = get_bits1(&s->gb);
4146
s->h263_long_vectors = s->unrestricted_mv;
4147
4148
if (get_bits1(&s->gb) != 0) {
4149
fprintf(stderr, "H263 SAC not supported\n");
4150
return -1; /* SAC: off */
4151
}
4152
if (get_bits1(&s->gb) != 0) {
4153
s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4154
}
4155
4156
if (get_bits1(&s->gb) != 0) {
4157
fprintf(stderr, "H263 PB frame not supported\n");
4158
return -1; /* not PB frame */
4159
}
4160
s->qscale = get_bits(&s->gb, 5);
4161
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5113
s->h263_long_vectors = get_bits1(&s->gb);
5114
5115
if (get_bits1(&s->gb) != 0) {
5116
av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5117
return -1; /* SAC: off */
5118
}
5119
s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5120
s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5121
5122
if (get_bits1(&s->gb) != 0) {
5123
av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5124
return -1; /* not PB frame */
5125
}
5126
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5127
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
4162
5128
4163
5129
s->width = width;
4164
5130
s->height = height;
5131
s->avctx->sample_aspect_ratio= (AVRational){12,11};
5132
s->avctx->time_base= (AVRational){1001, 30000};
4165
5133
} else {
4166
5134
int ufep;
4167
5135
4168
5136
/* H.263v2 */
4169
5137
s->h263_plus = 1;
4170
5138
ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
4171
5139
4172
/* ufep other than 0 and 1 are reserved */
5140
/* ufep other than 0 and 1 are reserved */
4173
5141
if (ufep == 1) {
4174
/* OPPTYPE */
5142
/* OPPTYPE */
4175
5143
format = get_bits(&s->gb, 3);
4176
5144
dprintf("ufep=1, format: %d\n", format);
4177
skip_bits(&s->gb,1); /* Custom PCF */
5145
s->custom_pcf= get_bits1(&s->gb);
4178
5146
s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
4179
skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
4180
if (get_bits1(&s->gb) != 0) {
4181
s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
4182
}
4183
if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
4184
s->h263_aic = 1;
4185
}
4186
4187
if (get_bits1(&s->gb) != 0) {
4188
fprintf(stderr, "Deblocking Filter not supported\n");
4189
}
4190
if (get_bits1(&s->gb) != 0) {
4191
fprintf(stderr, "Slice Structured not supported\n");
4192
}
4193
if (get_bits1(&s->gb) != 0) {
4194
fprintf(stderr, "Reference Picture Selection not supported\n");
4195
}
4196
if (get_bits1(&s->gb) != 0) {
4197
fprintf(stderr, "Independent Segment Decoding not supported\n");
4198
}
4199
if (get_bits1(&s->gb) != 0) {
4200
fprintf(stderr, "Alternative Inter VLC not supported\n");
4201
}
4202
if (get_bits1(&s->gb) != 0) {
4203
fprintf(stderr, "Modified Quantization not supported\n");
4204
}
4205
5147
if (get_bits1(&s->gb) != 0) {
5148
av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5149
}
5150
s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5151
s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5152
s->loop_filter= get_bits1(&s->gb);
5153
s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5154
5155
s->h263_slice_structured= get_bits1(&s->gb);
5156
if (get_bits1(&s->gb) != 0) {
5157
av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5158
}
5159
if (get_bits1(&s->gb) != 0) {
5160
av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5161
}
5162
s->alt_inter_vlc= get_bits1(&s->gb);
5163
s->modified_quant= get_bits1(&s->gb);
5164
if(s->modified_quant)
5165
s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5166
4206
5167
skip_bits(&s->gb, 1); /* Prevent start code emulation */
4207
5168
4208
5169
skip_bits(&s->gb, 3); /* Reserved */
4209
5170
} else if (ufep != 0) {
4210
fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
5171
av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
4211
5172
return -1;
4212
5173
}
4213
5174
4214
5175
/* MPPTYPE */
4215
s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
4216
dprintf("pict_type: %d\n", s->pict_type);
4217
if (s->pict_type != I_TYPE &&
4218
s->pict_type != P_TYPE)
5176
s->pict_type = get_bits(&s->gb, 3);
5177
switch(s->pict_type){
5178
case 0: s->pict_type= I_TYPE;break;
5179
case 1: s->pict_type= P_TYPE;break;
5180
case 3: s->pict_type= B_TYPE;break;
5181
case 7: s->pict_type= I_TYPE;break; //ZYGO
5182
default:
4219
5183
return -1;
5184
}
4220
5185
skip_bits(&s->gb, 2);
4221
5186
s->no_rounding = get_bits1(&s->gb);
4222
dprintf("RTYPE: %d\n", s->no_rounding);
4223
5187
skip_bits(&s->gb, 4);
4224
5188
4225
5189
/* Get the picture dimensions */
4226
5190
if (ufep) {
4227
5191
if (format == 6) {
4243
5207
dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
4244
5208
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
4245
5209
/* aspected dimensions */
4246
s->aspected_width = get_bits(&s->gb, 8);
4247
s->aspected_height = get_bits(&s->gb, 8);
5210
s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5211
s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
4248
5212
}else{
4249
s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4250
s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
5213
s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
4251
5214
}
4252
5215
} else {
4253
5216
width = h263_format[format][0];
4254
5217
height = h263_format[format][1];
5218
s->avctx->sample_aspect_ratio= (AVRational){12,11};
4255
5219
}
4256
5220
if ((width == 0) || (height == 0))
4257
5221
return -1;
4258
5222
s->width = width;
4259
5223
s->height = height;
5224
5225
if(s->custom_pcf){
5226
int gcd;
5227
s->avctx->time_base.den= 1800000;
5228
s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5229
s->avctx->time_base.num*= get_bits(&s->gb, 7);
5230
if(s->avctx->time_base.num == 0){
5231
av_log(s, AV_LOG_ERROR, "zero framerate\n");
5232
return -1;
5233
}
5234
gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5235
s->avctx->time_base.den /= gcd;
5236
s->avctx->time_base.num /= gcd;
5237
// av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5238
}else{
5239
s->avctx->time_base= (AVRational){1001, 30000};
5240
}
5241
}
5242
5243
if(s->custom_pcf){
5244
skip_bits(&s->gb, 2); //extended Temporal reference
5245
}
5246
5247
if (ufep) {
4260
5248
if (s->umvplus) {
4261
5249
if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
4262
skip_bits1(&s->gb);
5250
skip_bits1(&s->gb);
5251
}
5252
if(s->h263_slice_structured){
5253
if (get_bits1(&s->gb) != 0) {
5254
av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5255
}
5256
if (get_bits1(&s->gb) != 0) {
5257
av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5258
}
4263
5259
}
4264
5260
}
4265
5261
4266
5262
s->qscale = get_bits(&s->gb, 5);
4267
5263
}
5264
5265
s->mb_width = (s->width + 15) / 16;
5266
s->mb_height = (s->height + 15) / 16;
5267
s->mb_num = s->mb_width * s->mb_height;
5268
4268
5269
/* PEI */
4269
5270
while (get_bits1(&s->gb) != 0) {
4270
5271
skip_bits(&s->gb, 8);
4271
5272
}
5273
5274
if(s->h263_slice_structured){
5275
if (get_bits1(&s->gb) != 1) {
5276
av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5277
return -1;
5278
}
5279
5280
ff_h263_decode_mba(s);
5281
5282
if (get_bits1(&s->gb) != 1) {
5283
av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5284
return -1;
5285
}
5286
}
4272
5287
s->f_code = 1;
4273
5288
4274
5289
if(s->h263_aic){
4275
s->y_dc_scale_table=
4276
s->c_dc_scale_table= h263_aic_dc_scale_table;
5290
s->y_dc_scale_table=
5291
s->c_dc_scale_table= ff_aic_dc_scale_table;
4277
5292
}else{
4278
5293
s->y_dc_scale_table=
4279
5294
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
4280
5295
}
4281
5296
4282
5297
if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4283
printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n",
5298
av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
4284
5299
s->qscale, av_get_pict_type_char(s->pict_type),
4285
5300
s->gb.size_in_bits, 1-s->no_rounding,
4286
s->mv_type == MV_TYPE_8X8 ? "ADV" : "",
4287
s->umvplus ? "UMV" : "",
4288
s->h263_long_vectors ? "LONG" : "",
4289
s->h263_plus ? "+" : ""
4290
);
5301
s->obmc ? " AP" : "",
5302
s->umvplus ? " UMV" : "",
5303
s->h263_long_vectors ? " LONG" : "",
5304
s->h263_plus ? " +" : "",
5305
s->h263_aic ? " AIC" : "",
5306
s->alt_inter_vlc ? " AIV" : "",
5307
s->modified_quant ? " MQ" : "",
5308
s->loop_filter ? " LOOP" : "",
5309
s->h263_slice_structured ? " SS" : "",
5310
s->avctx->time_base.den, s->avctx->time_base.num
5311
);
4291
5312
}
5313
#if 1
5314
if (s->pict_type == I_TYPE && s->codec_tag == ff_get_fourcc("ZYGO")){
5315
int i,j;
5316
for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5317
av_log(s->avctx, AV_LOG_DEBUG, "\n");
5318
for(i=0; i<13; i++){
5319
for(j=0; j<3; j++){
5320
int v= get_bits(&s->gb, 8);
5321
v |= get_sbits(&s->gb, 8)<<8;
5322
av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5323
}
5324
av_log(s->avctx, AV_LOG_DEBUG, "\n");
5325
}
5326
for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5327
}
5328
#endif
4292
5329
4293
4294
5330
return 0;
4295
5331
}
4296
5332
4297
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
5333
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
4298
5334
{
4299
5335
int i;
4300
5336
int a= 2<<s->sprite_warping_accuracy;
4314
5350
int length;
4315
5351
int x=0, y=0;
4316
5352
4317
length= get_vlc(&s->gb, &sprite_trajectory);
4318
if(length){
4319
x= get_xbits(&s->gb, length);
4320
}
4321
if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
4322
4323
length= get_vlc(&s->gb, &sprite_trajectory);
4324
if(length){
4325
y=get_xbits(&s->gb, length);
4326
}
4327
skip_bits1(&s->gb); /* marker bit */
5353
length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5354
if(length){
5355
x= get_xbits(gb, length);
5356
}
5357
if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5358
5359
length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5360
if(length){
5361
y=get_xbits(gb, length);
5362
}
5363
skip_bits1(gb); /* marker bit */
4328
5364
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
4329
5365
d[i][0]= x;
4330
5366
d[i][1]= y;
4335
5371
w2= 1<<alpha;
4336
5372
h2= 1<<beta;
4337
5373
4338
// Note, the 4th point isnt used for GMC
5374
// Note, the 4th point isn't used for GMC
4339
5375
if(s->divx_version==500 && s->divx_build==413){
4340
5376
sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
4341
5377
sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
4353
5389
}
4354
5390
/* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
4355
5391
sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
4356
5392
4357
5393
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
4358
5394
// perhaps it should be reordered to be more readable ...
4359
5395
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
4360
5396
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
4361
virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5397
virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
4362
5398
+ ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
4363
virtual_ref[0][1]= 16*vop_ref[0][1]
5399
virtual_ref[0][1]= 16*vop_ref[0][1]
4364
5400
+ ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
4365
virtual_ref[1][0]= 16*vop_ref[0][0]
5401
virtual_ref[1][0]= 16*vop_ref[0][0]
4366
5402
+ ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
4367
virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5403
virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
4368
5404
+ ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
4369
5405
4370
5406
switch(s->num_sprite_warping_points)
4371
5407
{
4372
5408
case 0:
4404
5440
+ (1<<(alpha+rho-1));
4405
5441
s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
4406
5442
+( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
4407
+2*w2*r*sprite_ref[0][0]
4408
- 16*w2
5443
+2*w2*r*sprite_ref[0][0]
5444
- 16*w2
4409
5445
+ (1<<(alpha+rho+1)));
4410
s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5446
s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
4411
5447
+(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
4412
+2*w2*r*sprite_ref[0][1]
5448
+2*w2*r*sprite_ref[0][1]
4413
5449
- 16*w2
4414
5450
+ (1<<(alpha+rho+1)));
4415
5451
s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4416
5452
s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
4417
5453
s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
4418
5454
s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
4419
5455
4420
5456
s->sprite_shift[0]= alpha+rho;
4421
5457
s->sprite_shift[1]= alpha+rho+2;
4422
5458
break;
4446
5482
s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
4447
5483
s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
4448
5484
s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
4449
5485
4450
5486
s->sprite_shift[0]= alpha + beta + rho - min_ab;
4451
5487
s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
4452
5488
break;
4453
5489
}
4454
/* try to simplify the situation */
5490
/* try to simplify the situation */
4455
5491
if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
4456
5492
&& s->sprite_delta[0][1] == 0
4457
5493
&& s->sprite_delta[1][0] == 0
4487
5523
vop_ref[0][0], vop_ref[0][1],
4488
5524
vop_ref[1][0], vop_ref[1][1],
4489
5525
vop_ref[2][0], vop_ref[2][1],
4490
sprite_ref[0][0], sprite_ref[0][1],
4491
sprite_ref[1][0], sprite_ref[1][1],
4492
sprite_ref[2][0], sprite_ref[2][1],
4493
virtual_ref[0][0], virtual_ref[0][1],
5526
sprite_ref[0][0], sprite_ref[0][1],
5527
sprite_ref[1][0], sprite_ref[1][1],
5528
sprite_ref[2][0], sprite_ref[2][1],
5529
virtual_ref[0][0], virtual_ref[0][1],
4494
5530
virtual_ref[1][0], virtual_ref[1][1]
4495
5531
);
4496
5532
4497
5533
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
4498
5534
s->sprite_offset[0][0], s->sprite_offset[0][1],
4499
5535
s->sprite_delta[0][0], s->sprite_delta[0][1],
4515
5551
4516
5552
skip_bits1(gb);
4517
5553
skip_bits1(gb);
4518
5554
4519
5555
return 0;
4520
5556
}
4521
5557
4533
5569
}
4534
5570
//printf("vo type:%d\n",s->vo_type);
4535
5571
s->aspect_ratio_info= get_bits(gb, 4);
4536
if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
4537
s->aspected_width = get_bits(gb, 8); // par_width
4538
s->aspected_height = get_bits(gb, 8); // par_height
5572
if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5573
s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5574
s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
4539
5575
}else{
4540
s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
4541
s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
5576
s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
4542
5577
}
4543
5578
4544
5579
if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
4545
5580
int chroma_format= get_bits(gb, 2);
4546
5581
if(chroma_format!=1){
4547
printf("illegal chroma format\n");
5582
av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
4548
5583
}
4549
5584
s->low_delay= get_bits1(gb);
4550
5585
if(get_bits1(gb)){ /* vbv parameters */
4551
get_bits(gb, 15); /* first_half_bitrate */
4552
skip_bits1(gb); /* marker */
4553
get_bits(gb, 15); /* latter_half_bitrate */
4554
skip_bits1(gb); /* marker */
4555
get_bits(gb, 15); /* first_half_vbv_buffer_size */
4556
skip_bits1(gb); /* marker */
4557
get_bits(gb, 3); /* latter_half_vbv_buffer_size */
4558
get_bits(gb, 11); /* first_half_vbv_occupancy */
4559
skip_bits1(gb); /* marker */
4560
get_bits(gb, 15); /* latter_half_vbv_occupancy */
4561
skip_bits1(gb); /* marker */
5586
get_bits(gb, 15); /* first_half_bitrate */
5587
skip_bits1(gb); /* marker */
5588
get_bits(gb, 15); /* latter_half_bitrate */
5589
skip_bits1(gb); /* marker */
5590
get_bits(gb, 15); /* first_half_vbv_buffer_size */
5591
skip_bits1(gb); /* marker */
5592
get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5593
get_bits(gb, 11); /* first_half_vbv_occupancy */
5594
skip_bits1(gb); /* marker */
5595
get_bits(gb, 15); /* latter_half_vbv_occupancy */
5596
skip_bits1(gb); /* marker */
4562
5597
}
4563
5598
}else{
4564
// set low delay flag only once so the smart? low delay detection wont be overriden
5599
// set low delay flag only once the smartest? low delay detection won't be overriden
4565
5600
if(s->picture_number==0)
4566
5601
s->low_delay=0;
4567
5602
}
4568
5603
4569
5604
s->shape = get_bits(gb, 2); /* vol shape */
4570
if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
5605
if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
4571
5606
if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4572
printf("Gray shape not supported\n");
5607
av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
4573
5608
skip_bits(gb, 4); //video_object_layer_shape_extension
4574
5609
}
4575
5610
4576
5611
check_marker(gb, "before time_increment_resolution");
4577
4578
s->time_increment_resolution = get_bits(gb, 16);
4579
4580
s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
5612
5613
s->avctx->time_base.den = get_bits(gb, 16);
5614
if(!s->avctx->time_base.den){
5615
av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5616
return -1;
5617
}
5618
5619
s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
4581
5620
if (s->time_increment_bits < 1)
4582
5621
s->time_increment_bits = 1;
4583
5622
4584
5623
check_marker(gb, "before fixed_vop_rate");
4585
5624
4586
5625
if (get_bits1(gb) != 0) { /* fixed_vop_rate */
4587
skip_bits(gb, s->time_increment_bits);
4588
}
5626
s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5627
}else
5628
s->avctx->time_base.num = 1;
5629
5630
s->t_frame=0;
4589
5631
4590
5632
if (s->shape != BIN_ONLY_SHAPE) {
4591
5633
if (s->shape == RECT_SHAPE) {
4594
5636
skip_bits1(gb); /* marker */
4595
5637
height = get_bits(gb, 13);
4596
5638
skip_bits1(gb); /* marker */
4597
if(width && height){ /* they should be non zero but who knows ... */
5639
if(width && height && !(s->width && s->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
4598
5640
s->width = width;
4599
5641
s->height = height;
4600
5642
// printf("width/height: %d %d\n", width, height);
4601
5643
}
4602
5644
}
4603
4604
s->progressive_sequence= get_bits1(gb)^1;
4605
if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
4606
printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5645
5646
s->progressive_sequence=
5647
s->progressive_frame= get_bits1(gb)^1;
5648
s->interlaced_dct=0;
5649
if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5650
av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
4607
5651
if (vo_ver_id == 1) {
4608
5652
s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
4609
5653
} else {
4610
5654
s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
4611
5655
}
4612
if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
5656
if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
4613
5657
if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4614
5658
if(s->vol_sprite_usage==STATIC_SPRITE){
4615
5659
s->sprite_width = get_bits(gb, 13);
4625
5669
s->sprite_warping_accuracy = get_bits(gb, 2);
4626
5670
s->sprite_brightness_change= get_bits1(gb);
4627
5671
if(s->vol_sprite_usage==STATIC_SPRITE)
4628
s->low_latency_sprite= get_bits1(gb);
5672
s->low_latency_sprite= get_bits1(gb);
4629
5673
}
4630
5674
// FIXME sadct disable bit if verid!=1 && shape not rect
4631
5675
4632
5676
if (get_bits1(gb) == 1) { /* not_8_bit */
4633
5677
s->quant_precision = get_bits(gb, 4); /* quant_precision */
4634
if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
4635
if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
5678
if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5679
if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
4636
5680
} else {
4637
5681
s->quant_precision = 5;
4638
5682
}
4639
5683
4640
5684
// FIXME a bunch of grayscale shape things
4641
5685
4642
5686
if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
4643
5687
int i, v;
4644
5688
4645
5689
/* load default matrixes */
4646
5690
for(i=0; i<64; i++){
4647
5691
int j= s->dsp.idct_permutation[i];
4648
5692
v= ff_mpeg4_default_intra_matrix[i];
4649
5693
s->intra_matrix[j]= v;
4650
5694
s->chroma_intra_matrix[j]= v;
4651
5695
4652
5696
v= ff_mpeg4_default_non_intra_matrix[i];
4653
5697
s->inter_matrix[j]= v;
4654
5698
s->chroma_inter_matrix[j]= v;
4657
5701
/* load custom intra matrix */
4658
5702
if(get_bits1(gb)){
4659
5703
int last=0;
4660
for(i=0; i<64; i++){
5704
for(i=0; i<64; i++){
4661
5705
int j;
4662
5706
v= get_bits(gb, 8);
4663
5707
if(v==0) break;
4664
5708
4665
5709
last= v;
4666
5710
j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4667
5711
s->intra_matrix[j]= v;
4670
5714
4671
5715
/* replicate last value */
4672
5716
for(; i<64; i++){
4673
int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5717
int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4674
5718
s->intra_matrix[j]= last;
4675
5719
s->chroma_intra_matrix[j]= last;
4676
5720
}
4679
5723
/* load custom non intra matrix */
4680
5724
if(get_bits1(gb)){
4681
5725
int last=0;
4682
for(i=0; i<64; i++){
5726
for(i=0; i<64; i++){
4683
5727
int j;
4684
5728
v= get_bits(gb, 8);
4685
5729
if(v==0) break;
4692
5736
4693
5737
/* replicate last value */
4694
5738
for(; i<64; i++){
4695
int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5739
int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
4696
5740
s->inter_matrix[j]= last;
4697
5741
s->chroma_inter_matrix[j]= last;
4698
5742
}
4705
5749
s->quarter_sample= get_bits1(gb);
4706
5750
else s->quarter_sample=0;
4707
5751
4708
if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
5752
if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
4709
5753
4710
5754
s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
4711
5755
4713
5757
if(s->data_partitioning){
4714
5758
s->rvlc= get_bits1(gb);
4715
5759
}
4716
5760
4717
5761
if(vo_ver_id != 1) {
4718
5762
s->new_pred= get_bits1(gb);
4719
5763
if(s->new_pred){
4720
printf("new pred not supported\n");
5764
av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
4721
5765
skip_bits(gb, 2); /* requested upstream message type */
4722
5766
skip_bits1(gb); /* newpred segment type */
4723
5767
}
4724
5768
s->reduced_res_vop= get_bits1(gb);
4725
if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
5769
if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
4726
5770
}
4727
5771
else{
4728
5772
s->new_pred=0;
4739
5783
int h_sampling_factor_m;
4740
5784
int v_sampling_factor_n;
4741
5785
int v_sampling_factor_m;
4742
5786
4743
5787
s->hierachy_type= get_bits1(gb);
4744
5788
ref_layer_id= get_bits(gb, 4);
4745
5789
ref_layer_sampling_dir= get_bits1(gb);
4748
5792
v_sampling_factor_n= get_bits(gb, 5);
4749
5793
v_sampling_factor_m= get_bits(gb, 5);
4750
5794
s->enhancement_type= get_bits1(gb);
4751
4752
if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5795
5796
if( h_sampling_factor_n==0 || h_sampling_factor_m==0
4753
5797
|| v_sampling_factor_n==0 || v_sampling_factor_m==0){
4754
5798
4755
5799
// fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
4756
5800
s->scalability=0;
4757
5801
4758
5802
*gb= bak;
4759
5803
}else
4760
printf("scalability not supported\n");
4761
5804
av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5805
4762
5806
// bin shape stuff FIXME
4763
5807
}
4764
5808
}
4773
5817
char buf[256];
4774
5818
int i;
4775
5819
int e;
4776
int ver, build, ver2, ver3;
5820
int ver = 0, build = 0, ver2 = 0, ver3 = 0;
4777
5821
char last;
4778
5822
4779
buf[0]= show_bits(gb, 8);
4780
for(i=1; i<256; i++){
4781
buf[i]= show_bits(gb, 16)&0xFF;
4782
if(buf[i]==0) break;
4783
skip_bits(gb, 8);
5823
for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
5824
if(show_bits(gb, 23) == 0) break;
5825
buf[i]= get_bits(gb, 8);
4784
5826
}
4785
buf[255]=0;
5827
buf[i]=0;
4786
5828
4787
5829
/* divx detection */
4788
5830
e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
4793
5835
s->divx_build= build;
4794
5836
s->divx_packed= e==3 && last=='p';
4795
5837
}
4796
5838
4797
5839
/* ffmpeg detection */
4798
e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
5840
e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
4799
5841
if(e!=4)
4800
e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5842
e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5843
if(e!=4){
5844
e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5845
if (e>1)
5846
build= (ver<<16) + (ver2<<8) + ver3;
5847
}
4801
5848
if(e!=4){
4802
5849
if(strcmp(buf, "ffmpeg")==0){
4803
s->ffmpeg_version= 0x000406;
4804
5850
s->lavc_build= 4600;
4805
5851
}
4806
5852
}
4807
5853
if(e==4){
4808
s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
4809
5854
s->lavc_build= build;
4810
5855
}
4811
5856
4812
5857
/* xvid detection */
4813
5858
e=sscanf(buf, "XviD%d", &build);
4814
5859
if(e==1){
4822
5867
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
4823
5868
int time_incr, time_increment;
4824
5869
4825
s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5870
s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
4826
5871
if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
4827
printf("low_delay flag set, but shouldnt, clearing it\n");
5872
av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
4828
5873
s->low_delay=0;
4829
5874
}
4830
5875
4831
5876
s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
4832
5877
if(s->partitioned_frame)
4833
5878
s->decode_mb= mpeg4_decode_partitioned_mb;
4834
5879
else
4835
s->decode_mb= ff_h263_decode_mb;
5880
s->decode_mb= ff_mpeg4_decode_mb;
4836
5881
4837
if(s->time_increment_resolution==0){
4838
s->time_increment_resolution=1;
4839
// fprintf(stderr, "time_increment_resolution is illegal\n");
4840
}
4841
5882
time_incr=0;
4842
while (get_bits1(gb) != 0)
5883
while (get_bits1(gb) != 0)
4843
5884
time_incr++;
4844
5885
4845
5886
check_marker(gb, "before time_increment");
4846
4847
if(s->time_increment_bits==0){
4848
printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
5887
5888
if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5889
av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
4849
5890
4850
5891
for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
4851
5892
if(show_bits(gb, s->time_increment_bits+1)&1) break;
4852
5893
}
4853
5894
4854
printf("my guess is %d bits ;)\n",s->time_increment_bits);
5895
av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
4855
5896
}
4856
5897
4857
5898
if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
4858
5899
else time_increment= get_bits(gb, s->time_increment_bits);
4859
5900
4860
5901
// printf("%d %X\n", s->time_increment_bits, time_increment);
4861
//printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
5902
//av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame);
4862
5903
if(s->pict_type!=B_TYPE){
4863
5904
s->last_time_base= s->time_base;
4864
5905
s->time_base+= time_incr;
4865
s->time= s->time_base*s->time_increment_resolution + time_increment;
5906
s->time= s->time_base*s->avctx->time_base.den + time_increment;
4866
5907
if(s->workaround_bugs&FF_BUG_UMP4){
4867
5908
if(s->time < s->last_non_b_time){
4868
5909
// fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
4869
5910
s->time_base++;
4870
s->time+= s->time_increment_resolution;
5911
s->time+= s->avctx->time_base.den;
4871
5912
}
4872
5913
}
4873
5914
s->pp_time= s->time - s->last_non_b_time;
4874
5915
s->last_non_b_time= s->time;
4875
5916
}else{
4876
s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
5917
s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
4877
5918
s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
4878
5919
if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
4879
// printf("messed up order, seeking?, skiping current b frame\n");
4880
return FRAME_SKIPED;
5920
// printf("messed up order, maybe after seeking? skipping current b frame\n");
5921
return FRAME_SKIPPED;
4881
5922
}
4882
4883
if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
5923
ff_mpeg4_init_direct_mv(s);
5924
5925
if(s->t_frame==0) s->t_frame= s->pb_time;
4884
5926
if(s->t_frame==0) s->t_frame=1; // 1/0 protection
4885
//printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
4886
s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
4887
- ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
4888
s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
4889
- ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5927
s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5928
- ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5929
s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5930
- ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5931
if(!s->progressive_sequence){
5932
if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
5933
return FRAME_SKIPPED;
5934
}
4890
5935
}
4891
4892
s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
5936
//av_log(s->avctx, AV_LOG_DEBUG, "last nonb %"PRId64" last_base %d time %"PRId64" pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time);
5937
5938
if(s->avctx->time_base.num)
5939
s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5940
else
5941
s->current_picture_ptr->pts= AV_NOPTS_VALUE;
4893
5942
if(s->avctx->debug&FF_DEBUG_PTS)
4894
printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
4895
5943
av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5944
4896
5945
check_marker(gb, "before vop_coded");
4897
5946
4898
5947
/* vop coded */
4899
5948
if (get_bits1(gb) != 1){
4900
printf("vop not coded\n");
4901
return FRAME_SKIPED;
5949
if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5950
av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5951
return FRAME_SKIPPED;
4902
5952
}
4903
//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
4904
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5953
//printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5954
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
4905
5955
if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4906
5956
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
4907
5957
/* rounding type for motion estimation */
4908
s->no_rounding = get_bits1(gb);
5958
s->no_rounding = get_bits1(gb);
4909
5959
} else {
4910
s->no_rounding = 0;
5960
s->no_rounding = 0;
4911
5961
}
4912
5962
//FIXME reduced res stuff
4913
5963
4914
5964
if (s->shape != RECT_SHAPE) {
4915
5965
if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
4916
5966
int width, height, hor_spat_ref, ver_spat_ref;
4917
5967
4918
5968
width = get_bits(gb, 13);
4919
5969
skip_bits1(gb); /* marker */
4920
5970
height = get_bits(gb, 13);
4924
5974
ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
4925
5975
}
4926
5976
skip_bits1(gb); /* change_CR_disable */
4927
5977
4928
5978
if (get_bits1(gb) != 0) {
4929
5979
skip_bits(gb, 8); /* constant_alpha_value */
4930
5980
}
4931
5981
}
4932
5982
//FIXME complexity estimation stuff
4933
5983
4934
5984
if (s->shape != BIN_ONLY_SHAPE) {
4935
int t;
4936
t=get_bits(gb, 3); /* intra dc VLC threshold */
4937
//printf("threshold %d\n", t);
5985
s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
4938
5986
if(!s->progressive_sequence){
4939
5987
s->top_field_first= get_bits1(gb);
4940
5988
s->alternate_scan= get_bits1(gb);
4953
6001
ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
4954
6002
ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
4955
6003
}
4956
6004
4957
6005
if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
4958
mpeg4_decode_sprite_trajectory(s);
4959
if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4960
if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
6006
mpeg4_decode_sprite_trajectory(s, gb);
6007
if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
6008
if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
4961
6009
}
4962
6010
4963
6011
if (s->shape != BIN_ONLY_SHAPE) {
4964
s->qscale = get_bits(gb, s->quant_precision);
6012
s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
4965
6013
if(s->qscale==0){
4966
printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
6014
av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
4967
6015
return -1; // makes no sense to continue, as there is nothing left from the image then
4968
6016
}
4969
6017
4970
6018
if (s->pict_type != I_TYPE) {
4971
s->f_code = get_bits(gb, 3); /* fcode_for */
6019
s->f_code = get_bits(gb, 3); /* fcode_for */
4972
6020
if(s->f_code==0){
4973
printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
6021
av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
4974
6022
return -1; // makes no sense to continue, as the MV decoding will break very quickly
4975
6023
}
4976
6024
}else
4977
6025
s->f_code=1;
4978
6026
4979
6027
if (s->pict_type == B_TYPE) {
4980
6028
s->b_code = get_bits(gb, 3);
4981
6029
}else
4982
6030
s->b_code=1;
4983
6031
4984
6032
if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4985
printf("qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s\n",
4986
s->qscale, s->f_code, s->b_code,
4987
s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
4988
gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
6033
av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d\n",
6034
s->qscale, s->f_code, s->b_code,
6035
s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
6036
gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
4989
6037
s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
4990
s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ");
6038
s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
4991
6039
}
4992
6040
4993
6041
if(!s->scalability){
4998
6046
if(s->enhancement_type){
4999
6047
int load_backward_shape= get_bits1(gb);
5000
6048
if(load_backward_shape){
5001
printf("load backward shape isnt supported\n");
6049
av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
5002
6050
}
5003
6051
}
5004
6052
skip_bits(gb, 2); //ref_select_code
5005
6053
}
5006
6054
}
5007
/* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
5008
// note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
6055
/* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
6056
// note we cannot detect divx5 without b-frames easily (although it's buggy too)
5009
6057
if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5010
printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
6058
av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5011
6059
s->low_delay=1;
5012
6060
}
5013
6061
5014
s->picture_number++; // better than pic number==0 allways ;)
6062
s->picture_number++; // better than pic number==0 always ;)
5015
6063
5016
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
6064
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5017
6065
s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5018
6066
5019
6067
if(s->workaround_bugs&FF_BUG_EDGE){
5035
6083
5036
6084
/* search next start code */
5037
6085
align_get_bits(gb);
6086
6087
if(s->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6088
skip_bits(gb, 24);
6089
if(get_bits(gb, 8) == 0xF0)
6090
return decode_vop_header(s, gb);
6091
}
6092
5038
6093
startcode = 0xff;
5039
6094
for(;;) {
6095
if(get_bits_count(gb) >= gb->size_in_bits){
6096
if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6097
av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6098
return FRAME_SKIPPED; //divx bug
6099
}else
6100
return -1; //end of stream
6101
}
6102
6103
/* use the bits after the test */
5040
6104
v = get_bits(gb, 8);
5041
6105
startcode = ((startcode << 8) | v) & 0xffffffff;
5042
5043
if(get_bits_count(gb) >= gb->size_in_bits){
5044
if(gb->size_in_bits==8 && s->divx_version){
5045
printf("frame skip %d\n", gb->size_in_bits);
5046
return FRAME_SKIPED; //divx bug
5047
}else
5048
return -1; //end of stream
5049
}
5050
6106
5051
6107
if((startcode&0xFFFFFF00) != 0x100)
5052
6108
continue; //no startcode
5053
6109
5054
6110
if(s->avctx->debug&FF_DEBUG_STARTCODE){
5055
printf("startcode: %3X ", startcode);
5056
if (startcode<=0x11F) printf("Video Object Start");
5057
else if(startcode<=0x12F) printf("Video Object Layer Start");
5058
else if(startcode<=0x13F) printf("Reserved");
5059
else if(startcode<=0x15F) printf("FGS bp start");
5060
else if(startcode<=0x1AF) printf("Reserved");
5061
else if(startcode==0x1B0) printf("Visual Object Seq Start");
5062
else if(startcode==0x1B1) printf("Visual Object Seq End");
5063
else if(startcode==0x1B2) printf("User Data");
5064
else if(startcode==0x1B3) printf("Group of VOP start");
5065
else if(startcode==0x1B4) printf("Video Session Error");
5066
else if(startcode==0x1B5) printf("Visual Object Start");
5067
else if(startcode==0x1B6) printf("Video Object Plane start");
5068
else if(startcode==0x1B7) printf("slice start");
5069
else if(startcode==0x1B8) printf("extension start");
5070
else if(startcode==0x1B9) printf("fgs start");
5071
else if(startcode==0x1BA) printf("FBA Object start");
5072
else if(startcode==0x1BB) printf("FBA Object Plane start");
5073
else if(startcode==0x1BC) printf("Mesh Object start");
5074
else if(startcode==0x1BD) printf("Mesh Object Plane start");
5075
else if(startcode==0x1BE) printf("Still Textutre Object start");
5076
else if(startcode==0x1BF) printf("Textutre Spatial Layer start");
5077
else if(startcode==0x1C0) printf("Textutre SNR Layer start");
5078
else if(startcode==0x1C1) printf("Textutre Tile start");
5079
else if(startcode==0x1C2) printf("Textutre Shape Layer start");
5080
else if(startcode==0x1C3) printf("stuffing start");
5081
else if(startcode<=0x1C5) printf("reserved");
5082
else if(startcode<=0x1FF) printf("System start");
5083
printf(" at %d\n", get_bits_count(gb));
6111
av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6112
if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6113
else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6114
else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6115
else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6116
else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6117
else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6118
else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6119
else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6120
else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6121
else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6122
else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6123
else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6124
else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6125
else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6126
else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6127
else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6128
else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6129
else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6130
else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6131
else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6132
else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6133
else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6134
else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6135
else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6136
else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6137
else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6138
else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6139
av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
5084
6140
}
5085
6141
5086
switch(startcode){
5087
case 0x120:
5088
if(decode_vol_header(s, gb) < 0)
6142
if(startcode >= 0x120 && startcode <= 0x12F){
6143
if(decode_vol_header(s, gb) < 0)
5089
6144
return -1;
5090
break;
5091
case USER_DATA_STARTCODE:
6145
}
6146
else if(startcode == USER_DATA_STARTCODE){
5092
6147
decode_user_data(s, gb);
5093
break;
5094
case GOP_STARTCODE:
6148
}
6149
else if(startcode == GOP_STARTCODE){
5095
6150
mpeg4_decode_gop_header(s, gb);
5096
break;
5097
case VOP_STARTCODE:
6151
}
6152
else if(startcode == VOP_STARTCODE){
5098
6153
return decode_vop_header(s, gb);
5099
default:
5100
break;
5101
6154
}
5102
6155
5103
6156
align_get_bits(gb);
5112
6165
5113
6166
/* picture header */
5114
6167
if (get_bits_long(&s->gb, 22) != 0x20) {
5115
fprintf(stderr, "Bad picture start code\n");
6168
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5116
6169
return -1;
5117
6170
}
5118
6171
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
5119
6172
5120
6173
if (get_bits1(&s->gb) != 1) {
5121
fprintf(stderr, "Bad marker\n");
5122
return -1; /* marker */
6174
av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6175
return -1; /* marker */
5123
6176
}
5124
6177
if (get_bits1(&s->gb) != 0) {
5125
fprintf(stderr, "Bad H263 id\n");
5126
return -1; /* h263 id */
6178
av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6179
return -1; /* h263 id */
5127
6180
}
5128
skip_bits1(&s->gb); /* split screen off */
5129
skip_bits1(&s->gb); /* camera off */
5130
skip_bits1(&s->gb); /* freeze picture release off */
6181
skip_bits1(&s->gb); /* split screen off */
6182
skip_bits1(&s->gb); /* camera off */
6183
skip_bits1(&s->gb); /* freeze picture release off */
5131
6184
5132
6185
format = get_bits(&s->gb, 3);
5133
6186
if (format != 7) {
5134
fprintf(stderr, "Intel H263 free format not supported\n");
6187
av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
5135
6188
return -1;
5136
6189
}
5137
6190
s->h263_plus = 0;
5138
6191
5139
6192
s->pict_type = I_TYPE + get_bits1(&s->gb);
5140
5141
s->unrestricted_mv = get_bits1(&s->gb);
6193
6194
s->unrestricted_mv = get_bits1(&s->gb);
5142
6195
s->h263_long_vectors = s->unrestricted_mv;
5143
6196
5144
6197
if (get_bits1(&s->gb) != 0) {
5145
fprintf(stderr, "SAC not supported\n");
5146
return -1; /* SAC: off */
5147
}
5148
if (get_bits1(&s->gb) != 0) {
5149
fprintf(stderr, "Advanced Prediction Mode not supported\n");
5150
return -1; /* advanced prediction mode: off */
5151
}
5152
if (get_bits1(&s->gb) != 0) {
5153
fprintf(stderr, "PB frame mode no supported\n");
5154
return -1; /* PB frame mode */
6198
av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6199
return -1; /* SAC: off */
6200
}
6201
if (get_bits1(&s->gb) != 0) {
6202
s->obmc= 1;
6203
av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6204
// return -1; /* advanced prediction mode: off */
6205
}
6206
if (get_bits1(&s->gb) != 0) {
6207
av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6208
return -1; /* PB frame mode */
5155
6209
}
5156
6210
5157
6211
/* skip unknown header garbage */
5158
6212
skip_bits(&s->gb, 41);
5159
6213
5160
s->qscale = get_bits(&s->gb, 5);
5161
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6214
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6215
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5162
6216
5163
6217
/* PEI */
5164
6218
while (get_bits1(&s->gb) != 0) {
5178
6232
5179
6233
/* picture header */
5180
6234
if (get_bits_long(&s->gb, 17) != 1) {
5181
fprintf(stderr, "Bad picture start code\n");
6235
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5182
6236
return -1;
5183
6237
}
5184
6238
format = get_bits(&s->gb, 5);
5185
6239
if (format != 0 && format != 1) {
5186
fprintf(stderr, "Bad picture format\n");
6240
av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
5187
6241
return -1;
5188
6242
}
5189
6243
s->h263_flv = format+1;
5222
6276
width = height = 0;
5223
6277
break;
5224
6278
}
5225
if ((width == 0) || (height == 0))
6279
if(avcodec_check_dimensions(s->avctx, width, height))
5226
6280
return -1;
5227
6281
s->width = width;
5228
6282
s->height = height;
5229
6283
5230
6284
s->pict_type = I_TYPE + get_bits(&s->gb, 2);
5231
if (s->pict_type > P_TYPE)
6285
s->dropable= s->pict_type > P_TYPE;
6286
if (s->dropable)
5232
6287
s->pict_type = P_TYPE;
5233
skip_bits1(&s->gb); /* deblocking flag */
5234
s->qscale = get_bits(&s->gb, 5);
6288
6289
skip_bits1(&s->gb); /* deblocking flag */
6290
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5235
6291
5236
6292
s->h263_plus = 0;
5237
6293
5245
6301
s->f_code = 1;
5246
6302
5247
6303
if(s->avctx->debug & FF_DEBUG_PICT_INFO){
5248
printf("%c esc_type:%d, qp:%d num:%d\n",
5249
av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6304
av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6305
s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
5250
6306
}
5251
6307
5252
6308
s->y_dc_scale_table=
5253
6309
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5254
6310
Loggerhead is a web-based interface for Breezy
Version: 2.0.1