2
* H263/MPEG4 backend for ffmpeg encoder and decoder
3
* Copyright (c) 2000,2001 Fabrice Bellard.
5
* Copyright (c) 2001 Juan J. Sierralta P.
6
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
8
* This library is free software; you can redistribute it and/or
9
* modify it under the terms of the GNU Lesser General Public
10
* License as published by the Free Software Foundation; either
11
* version 2 of the License, or (at your option) any later version.
13
* This library is distributed in the hope that it will be useful,
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
* Lesser General Public License for more details.
18
* You should have received a copy of the GNU Lesser General Public
19
* License along with this library; if not, write to the Free Software
20
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
* ac prediction encoding, b-frame support, error resilience, optimizations,
23
* qpel decoding, gmc decoding, interlaced decoding,
24
* by Michael Niedermayer <michaelni@gmx.at>
38
#include "mpegvideo.h"
40
#include "mpeg4data.h"
45
#define INTRA_MCBPC_VLC_BITS 6
46
#define INTER_MCBPC_VLC_BITS 7
47
#define CBPY_VLC_BITS 6
50
#define SPRITE_TRAJ_VLC_BITS 6
51
#define MB_TYPE_B_VLC_BITS 4
52
#define TEX_VLC_BITS 9
53
#define H263_MBTYPE_B_VLC_BITS 6
54
#define CBPC_B_VLC_BITS 3
56
#ifdef CONFIG_ENCODERS
57
static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
59
static void h263p_encode_umotion(MpegEncContext * s, int val);
60
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
61
int n, int dc, uint8_t *scan_table,
62
PutBitContext *dc_pb, PutBitContext *ac_pb);
65
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
66
static int h263p_decode_umotion(MpegEncContext * s, int pred);
67
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
69
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
70
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
71
int n, int coded, int intra, int rvlc);
72
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
74
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
75
#ifdef CONFIG_ENCODERS
76
static void mpeg4_encode_visual_object_header(MpegEncContext * s);
77
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
78
#endif //CONFIG_ENCODERS
79
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
80
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
82
#ifdef CONFIG_ENCODERS
83
static uint8_t uni_DCtab_lum_len[512];
84
static uint8_t uni_DCtab_chrom_len[512];
85
static uint16_t uni_DCtab_lum_bits[512];
86
static uint16_t uni_DCtab_chrom_bits[512];
88
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
89
static uint8_t fcode_tab[MAX_MV*2+1];
90
static uint8_t umv_fcode_tab[MAX_MV*2+1];
92
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
93
static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
94
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
95
static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
96
static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
97
static uint8_t uni_h263_inter_rl_len [64*64*2*2];
98
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
99
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
100
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
113
#if 0 //3IV1 is quite rare and it slows things down a tiny bit
114
#define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
119
int h263_get_picture_format(int width, int height)
123
if (width == 128 && height == 96)
125
else if (width == 176 && height == 144)
127
else if (width == 352 && height == 288)
129
else if (width == 704 && height == 576)
131
else if (width == 1408 && height == 1152)
138
#ifdef CONFIG_ENCODERS
140
static void aspect_to_info(MpegEncContext * s, AVRational aspect){
143
if(aspect.num==0) aspect= (AVRational){1,1};
146
if(av_cmp_q(pixel_aspect[i], aspect) == 0){
147
s->aspect_ratio_info=i;
152
s->aspect_ratio_info= FF_ASPECT_EXTENDED;
155
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
159
align_put_bits(&s->pb);
161
put_bits(&s->pb, 17, 1);
162
put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
163
put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp
164
s->avctx->time_base.den) & 0xff); /* TemporalReference */
165
if (s->width == 352 && s->height == 288)
167
else if (s->width == 176 && s->height == 144)
169
else if (s->width == 128 && s->height == 96)
171
else if (s->width == 320 && s->height == 240)
173
else if (s->width == 160 && s->height == 120)
175
else if (s->width <= 255 && s->height <= 255)
176
format = 0; /* use 1 byte width & height */
178
format = 1; /* use 2 bytes width & height */
179
put_bits(&s->pb, 3, format); /* PictureSize */
181
put_bits(&s->pb, 8, s->width);
182
put_bits(&s->pb, 8, s->height);
183
} else if (format == 1) {
184
put_bits(&s->pb, 16, s->width);
185
put_bits(&s->pb, 16, s->height);
187
put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
188
put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
189
put_bits(&s->pb, 5, s->qscale); /* Quantizer */
190
put_bits(&s->pb, 1, 0); /* ExtraInformation */
194
s->c_dc_scale_table= ff_aic_dc_scale_table;
197
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
201
void h263_encode_picture_header(MpegEncContext * s, int picture_number)
203
int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
204
int best_clock_code=1;
206
int best_error= INT_MAX;
211
div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
212
div= clip(1, div, 127);
213
error= ABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
214
if(error < best_error){
221
s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
222
coded_frame_rate= 1800000;
223
coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
225
align_put_bits(&s->pb);
227
/* Update the pointer to last GOB */
228
s->ptr_lastgob = pbBufPtr(&s->pb);
229
put_bits(&s->pb, 22, 0x20); /* PSC */
230
temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
231
(coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
232
put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
234
put_bits(&s->pb, 1, 1); /* marker */
235
put_bits(&s->pb, 1, 0); /* h263 id */
236
put_bits(&s->pb, 1, 0); /* split screen off */
237
put_bits(&s->pb, 1, 0); /* camera off */
238
put_bits(&s->pb, 1, 0); /* freeze picture release off */
240
format = h263_get_picture_format(s->width, s->height);
243
put_bits(&s->pb, 3, format);
244
put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
245
/* By now UMV IS DISABLED ON H.263v1, since the restrictions
246
of H.263v1 UMV implies to check the predicted MV after
247
calculation of the current MB to see if we're on the limits */
248
put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
249
put_bits(&s->pb, 1, 0); /* SAC: off */
250
put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
251
put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
252
put_bits(&s->pb, 5, s->qscale);
253
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
257
/* H.263 Plus PTYPE */
259
put_bits(&s->pb, 3, 7);
260
put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
262
put_bits(&s->pb,3,6); /* Custom Source Format */
264
put_bits(&s->pb, 3, format);
266
put_bits(&s->pb,1, s->custom_pcf);
267
put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
268
put_bits(&s->pb,1,0); /* SAC: off */
269
put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
270
put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
271
put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
272
put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
273
put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
274
put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
275
put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
276
put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
277
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
278
put_bits(&s->pb,3,0); /* Reserved */
280
put_bits(&s->pb, 3, s->pict_type == P_TYPE);
282
put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
283
put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
284
put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
285
put_bits(&s->pb,2,0); /* Reserved */
286
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
288
/* This should be here if PLUSPTYPE */
289
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
292
/* Custom Picture Format (CPFMT) */
293
aspect_to_info(s, s->avctx->sample_aspect_ratio);
295
put_bits(&s->pb,4,s->aspect_ratio_info);
296
put_bits(&s->pb,9,(s->width >> 2) - 1);
297
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
298
put_bits(&s->pb,9,(s->height >> 2));
299
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
300
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
301
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
306
put_bits(&s->pb, 1, best_clock_code);
307
put_bits(&s->pb, 7, best_divisor);
309
put_bits(&s->pb, 2, (temp_ref>>8)&3);
312
/* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
314
// put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
315
//FIXME check actual requested range
316
put_bits(&s->pb,2,1); /* unlimited */
317
if(s->h263_slice_structured)
318
put_bits(&s->pb,2,0); /* no weird submodes */
320
put_bits(&s->pb, 5, s->qscale);
323
put_bits(&s->pb, 1, 0); /* no PEI */
325
if(s->h263_slice_structured){
326
put_bits(&s->pb, 1, 1);
328
assert(s->mb_x == 0 && s->mb_y == 0);
329
ff_h263_encode_mba(s);
331
put_bits(&s->pb, 1, 1);
336
s->c_dc_scale_table= ff_aic_dc_scale_table;
339
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344
* Encodes a group of blocks header.
346
void h263_encode_gob_header(MpegEncContext * s, int mb_line)
348
put_bits(&s->pb, 17, 1); /* GBSC */
350
if(s->h263_slice_structured){
351
put_bits(&s->pb, 1, 1);
353
ff_h263_encode_mba(s);
356
put_bits(&s->pb, 1, 1);
357
put_bits(&s->pb, 5, s->qscale); /* GQUANT */
358
put_bits(&s->pb, 1, 1);
359
put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
361
int gob_number= mb_line / s->gob_index;
363
put_bits(&s->pb, 5, gob_number); /* GN */
364
put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
365
put_bits(&s->pb, 5, s->qscale); /* GQUANT */
369
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
374
for(j=1; j<=block_last_index; j++){
375
const int index= scantable[j];
376
int level= block[index];
379
if((level&(~127)) == 0){
380
if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
381
else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
383
rate += s->ac_esc_length;
393
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
397
int8_t * const qscale_table= s->current_picture.qscale_table;
399
memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
402
int16_t *ac_val, *ac_val1;
404
score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
406
ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
409
const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
411
ac_val-= s->block_wrap[n]*16;
412
if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
415
const int level= block[n][s->dsp.idct_permutation[i ]];
416
block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
417
ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
421
/* different qscale, we must rescale */
423
const int level= block[n][s->dsp.idct_permutation[i ]];
424
block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
425
ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
429
st[n]= s->intra_h_scantable.permutated;
431
const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
432
/* left prediction */
434
if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
437
const int level= block[n][s->dsp.idct_permutation[i<<3]];
438
block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
440
ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
443
/* different qscale, we must rescale */
445
const int level= block[n][s->dsp.idct_permutation[i<<3]];
446
block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
448
ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
451
st[n]= s->intra_v_scantable.permutated;
454
for(i=63; i>0; i--) //FIXME optimize
455
if(block[n][ st[n][i] ]) break;
456
s->block_last_index[n]= i;
458
score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
464
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
memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
470
int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
472
st[n]= s->intra_scantable.permutated;
476
block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
479
/* left prediction */
481
block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
488
* modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
490
void ff_clean_h263_qscales(MpegEncContext *s){
492
int8_t * const qscale_table= s->current_picture.qscale_table;
494
for(i=1; i<s->mb_num; i++){
495
if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
496
qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
498
for(i=s->mb_num-2; i>=0; i--){
499
if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
500
qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
503
if(s->codec_id != CODEC_ID_H263P){
504
for(i=1; i<s->mb_num; i++){
505
int mb_xy= s->mb_index2xy[i];
507
if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
508
s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
509
s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
516
* modify mb_type & qscale so that encoding is acually possible in mpeg4
518
void ff_clean_mpeg4_qscales(MpegEncContext *s){
520
int8_t * const qscale_table= s->current_picture.qscale_table;
522
ff_clean_h263_qscales(s);
524
if(s->pict_type== B_TYPE){
526
/* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
528
for(i=0; i<s->mb_num; i++){
529
int mb_xy= s->mb_index2xy[i];
530
odd += qscale_table[mb_xy]&1;
533
if(2*odd > s->mb_num) odd=1;
536
for(i=0; i<s->mb_num; i++){
537
int mb_xy= s->mb_index2xy[i];
538
if((qscale_table[mb_xy]&1) != odd)
539
qscale_table[mb_xy]++;
540
if(qscale_table[mb_xy] > 31)
541
qscale_table[mb_xy]= 31;
544
for(i=1; i<s->mb_num; i++){
545
int mb_xy= s->mb_index2xy[i];
546
if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
547
s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
548
s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
554
#endif //CONFIG_ENCODERS
557
* @return the mb_type
559
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
560
const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
561
const int colocated_mb_type= s->next_picture.mb_type[mb_index];
562
int xy= s->block_index[0];
563
uint16_t time_pp= s->pp_time;
564
uint16_t time_pb= s->pb_time;
567
//FIXME avoid divides
569
if(IS_8X8(colocated_mb_type)){
570
s->mv_type = MV_TYPE_8X8;
572
xy= s->block_index[i];
573
s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
574
s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
575
s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
576
: s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
577
s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1]
578
: s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
580
return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
581
} else if(IS_INTERLACED(colocated_mb_type)){
582
s->mv_type = MV_TYPE_FIELD;
584
int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
585
if(s->top_field_first){
586
time_pp= s->pp_field_time - field_select + i;
587
time_pb= s->pb_field_time - field_select + i;
589
time_pp= s->pp_field_time + field_select - i;
590
time_pb= s->pb_field_time + field_select - i;
592
s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
593
s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
594
s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
595
: s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
596
s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
597
: s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
599
return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
601
s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
602
s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
603
s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->next_picture.motion_val[0][xy][0]
604
: s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
605
s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->next_picture.motion_val[0][xy][1]
606
: s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
607
if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
608
s->mv_type= MV_TYPE_16X16;
610
s->mv_type= MV_TYPE_8X8;
611
return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
615
void ff_h263_update_motion_val(MpegEncContext * s){
616
const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
617
//FIXME a lot of that is only needed for !low_delay
618
const int wrap = s->b8_stride;
619
const int xy = s->block_index[0];
621
s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
623
if(s->mv_type != MV_TYPE_8X8){
624
int motion_x, motion_y;
628
} else if (s->mv_type == MV_TYPE_16X16) {
629
motion_x = s->mv[0][0][0];
630
motion_y = s->mv[0][0][1];
631
} else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
633
motion_x = s->mv[0][0][0] + s->mv[0][1][0];
634
motion_y = s->mv[0][0][1] + s->mv[0][1][1];
635
motion_x = (motion_x>>1) | (motion_x&1);
637
s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
638
s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
640
s->current_picture.ref_index[0][xy ]=
641
s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
642
s->current_picture.ref_index[0][xy + wrap ]=
643
s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
646
/* no update if 8X8 because it has been done during parsing */
647
s->current_picture.motion_val[0][xy][0] = motion_x;
648
s->current_picture.motion_val[0][xy][1] = motion_y;
649
s->current_picture.motion_val[0][xy + 1][0] = motion_x;
650
s->current_picture.motion_val[0][xy + 1][1] = motion_y;
651
s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
652
s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
653
s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
654
s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
657
if(s->encoding){ //FIXME encoding MUST be cleaned up
658
if (s->mv_type == MV_TYPE_8X8)
659
s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
661
s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
663
s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
667
#ifdef CONFIG_ENCODERS
669
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
670
int l, bit_size, code;
675
bit_size = f_code - 1;
676
/* modulo encoding */
677
l= INT_BIT - 6 - bit_size;
680
code = (val >> bit_size) + 1;
682
return mvtab[code][1] + 1 + bit_size;
686
static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
687
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
688
skip_put_bits(&s->pb,
689
h263_get_motion_length(s, x, f_code)
690
+h263_get_motion_length(s, y, f_code));
692
ff_h263_encode_motion(s, x, f_code);
693
ff_h263_encode_motion(s, y, f_code);
697
static inline int get_p_cbp(MpegEncContext * s,
698
DCTELEM block[6][64],
699
int motion_x, int motion_y){
702
if(s->flags & CODEC_FLAG_CBP_RD){
703
int best_cbpy_score= INT_MAX;
704
int best_cbpc_score= INT_MAX;
705
int cbpc = (-1), cbpy= (-1);
706
const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
707
const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
710
int score= inter_MCBPC_bits[i + offset] * lambda;
711
if(i&1) score += s->coded_score[5];
712
if(i&2) score += s->coded_score[4];
714
if(score < best_cbpc_score){
715
best_cbpc_score= score;
721
int score= cbpy_tab[i ^ 0xF][1] * lambda;
722
if(i&1) score += s->coded_score[3];
723
if(i&2) score += s->coded_score[2];
724
if(i&4) score += s->coded_score[1];
725
if(i&8) score += s->coded_score[0];
727
if(score < best_cbpy_score){
728
best_cbpy_score= score;
733
if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
734
if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
738
for (i = 0; i < 6; i++) {
739
if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
740
s->block_last_index[i]= -1;
741
memset(s->block[i], 0, sizeof(DCTELEM)*64);
746
for (i = 0; i < 6; i++) {
747
if (s->block_last_index[i] >= 0)
754
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
755
int motion_x, int motion_y, int mb_type){
758
if(s->flags & CODEC_FLAG_CBP_RD){
760
const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
763
if(s->coded_score[i] < 0){
764
score += s->coded_score[i];
771
if ((motion_x | motion_y | s->dquant | mb_type) == 0){
772
zero_score-= 4; //2*MV + mb_type + cbp bit
776
if(zero_score <= score){
781
for (i = 0; i < 6; i++) {
782
if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
783
s->block_last_index[i]= -1;
784
memset(s->block[i], 0, sizeof(DCTELEM)*64);
788
for (i = 0; i < 6; i++) {
789
if (s->block_last_index[i] >= 0)
796
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
797
uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
801
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
802
for (i = 0; i < 6; i++) {
803
skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
806
/* encode each block */
807
for (i = 0; i < 6; i++) {
808
mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
812
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
813
for (i = 0; i < 6; i++) {
814
skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
817
/* encode each block */
818
for (i = 0; i < 6; i++) {
819
mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
825
void mpeg4_encode_mb(MpegEncContext * s,
826
DCTELEM block[6][64],
827
int motion_x, int motion_y)
829
int cbpc, cbpy, pred_x, pred_y;
830
PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
831
PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
832
PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
833
const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
834
const int dquant_code[5]= {1,0,9,2,3};
836
// printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
840
if(s->pict_type==B_TYPE){
841
static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
842
int mb_type= mb_type_table[s->mv_dir];
849
s->last_mv[i][1][1]= 0;
853
assert(s->dquant>=-2 && s->dquant<=2);
854
assert((s->dquant&1)==0);
857
/* nothing to do if this MB was skipped in the next P Frame */
858
if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
864
s->mv_dir= MV_DIR_FORWARD; //doesn't matter
865
s->qscale -= s->dquant;
871
cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
873
if ((cbp | motion_x | motion_y | mb_type) ==0) {
874
/* direct MB with MV={0,0} */
875
assert(s->dquant==0);
877
put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
879
if(interleaved_stats){
887
put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
888
put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
889
put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :)
890
if(cbp) put_bits(&s->pb, 6, cbp);
894
put_bits(&s->pb, 2, (s->dquant>>2)+3);
896
put_bits(&s->pb, 1, 0);
898
s->qscale -= s->dquant;
900
if(!s->progressive_sequence){
902
put_bits(&s->pb, 1, s->interlaced_dct);
903
if(mb_type) // not direct mode
904
put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
907
if(interleaved_stats){
908
s->misc_bits+= get_bits_diff(s);
912
assert(s->mv_dir & MV_DIRECT);
913
ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
917
assert(mb_type > 0 && mb_type < 4);
918
if(s->mv_type != MV_TYPE_FIELD){
919
if(s->mv_dir & MV_DIR_FORWARD){
920
ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
921
s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
922
s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
923
s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
926
if(s->mv_dir & MV_DIR_BACKWARD){
927
ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
928
s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
929
s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
930
s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
934
if(s->mv_dir & MV_DIR_FORWARD){
935
put_bits(&s->pb, 1, s->field_select[0][0]);
936
put_bits(&s->pb, 1, s->field_select[0][1]);
938
if(s->mv_dir & MV_DIR_BACKWARD){
939
put_bits(&s->pb, 1, s->field_select[1][0]);
940
put_bits(&s->pb, 1, s->field_select[1][1]);
942
if(s->mv_dir & MV_DIR_FORWARD){
944
ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
945
s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
946
s->last_mv[0][i][0]= s->mv[0][i][0];
947
s->last_mv[0][i][1]= s->mv[0][i][1]*2;
951
if(s->mv_dir & MV_DIR_BACKWARD){
953
ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
954
s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
955
s->last_mv[1][i][0]= s->mv[1][i][0];
956
s->last_mv[1][i][1]= s->mv[1][i][1]*2;
963
if(interleaved_stats){
964
s->mv_bits+= get_bits_diff(s);
967
mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
969
if(interleaved_stats){
970
s->p_tex_bits+= get_bits_diff(s);
973
}else{ /* s->pict_type==B_TYPE */
974
cbp= get_p_cbp(s, block, motion_x, motion_y);
976
if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
977
/* check if the B frames can skip it too, as we must skip it if we skip here
978
why didn't they just compress the skip-mb bits instead of reusing them ?! */
979
if(s->max_b_frames>0){
986
if(x+16 > s->width) x= s->width-16;
987
if(y+16 > s->height) y= s->height-16;
989
offset= x + y*s->linesize;
990
p_pic= s->new_picture.data[0] + offset;
993
for(i=0; i<s->max_b_frames; i++){
996
Picture *pic= s->reordered_input_picture[i+1];
998
if(pic==NULL || pic->pict_type!=B_TYPE) break;
1000
b_pic= pic->data[0] + offset + 16; //FIXME +16
1001
diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
1002
if(diff>s->qscale*70){ //FIXME check that 70 is optimal
1010
if(s->mb_skipped==1){
1011
/* skip macroblock */
1012
put_bits(&s->pb, 1, 1);
1014
if(interleaved_stats){
1024
put_bits(&s->pb, 1, 0); /* mb coded */
1028
if(s->mv_type==MV_TYPE_16X16){
1029
if(s->dquant) cbpc+= 8;
1031
inter_MCBPC_bits[cbpc],
1032
inter_MCBPC_code[cbpc]);
1034
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1036
put_bits(pb2, 2, dquant_code[s->dquant+2]);
1038
if(!s->progressive_sequence){
1040
put_bits(pb2, 1, s->interlaced_dct);
1041
put_bits(pb2, 1, 0);
1044
if(interleaved_stats){
1045
s->misc_bits+= get_bits_diff(s);
1048
/* motion vectors: 16x16 mode */
1049
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1051
ff_h263_encode_motion_vector(s, motion_x - pred_x,
1052
motion_y - pred_y, s->f_code);
1053
}else if(s->mv_type==MV_TYPE_FIELD){
1054
if(s->dquant) cbpc+= 8;
1056
inter_MCBPC_bits[cbpc],
1057
inter_MCBPC_code[cbpc]);
1059
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1061
put_bits(pb2, 2, dquant_code[s->dquant+2]);
1063
assert(!s->progressive_sequence);
1065
put_bits(pb2, 1, s->interlaced_dct);
1066
put_bits(pb2, 1, 1);
1068
if(interleaved_stats){
1069
s->misc_bits+= get_bits_diff(s);
1072
/* motion vectors: 16x8 interlaced mode */
1073
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1076
put_bits(&s->pb, 1, s->field_select[0][0]);
1077
put_bits(&s->pb, 1, s->field_select[0][1]);
1079
ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
1080
s->mv[0][0][1] - pred_y, s->f_code);
1081
ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
1082
s->mv[0][1][1] - pred_y, s->f_code);
1084
assert(s->mv_type==MV_TYPE_8X8);
1086
inter_MCBPC_bits[cbpc+16],
1087
inter_MCBPC_code[cbpc+16]);
1088
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1090
if(!s->progressive_sequence){
1092
put_bits(pb2, 1, s->interlaced_dct);
1095
if(interleaved_stats){
1096
s->misc_bits+= get_bits_diff(s);
1100
/* motion vectors: 8x8 mode*/
1101
h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1103
ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
1104
s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
1108
if(interleaved_stats){
1109
s->mv_bits+= get_bits_diff(s);
1112
mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
1114
if(interleaved_stats){
1115
s->p_tex_bits+= get_bits_diff(s);
1121
int dc_diff[6]; //dc values with the dc prediction subtracted
1122
int dir[6]; //prediction direction
1123
int zigzag_last_index[6];
1124
uint8_t *scan_table[6];
1128
dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
1131
if(s->flags & CODEC_FLAG_AC_PRED){
1132
s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
1134
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1137
scan_table[i]= s->intra_scantable.permutated;
1142
for (i = 0; i < 6; i++) {
1143
if (s->block_last_index[i] >= 1)
1144
cbp |= 1 << (5 - i);
1148
if (s->pict_type == I_TYPE) {
1149
if(s->dquant) cbpc+=4;
1151
intra_MCBPC_bits[cbpc],
1152
intra_MCBPC_code[cbpc]);
1154
if(s->dquant) cbpc+=8;
1155
put_bits(&s->pb, 1, 0); /* mb coded */
1157
inter_MCBPC_bits[cbpc + 4],
1158
inter_MCBPC_code[cbpc + 4]);
1160
put_bits(pb2, 1, s->ac_pred);
1162
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1164
put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
1166
if(!s->progressive_sequence){
1167
put_bits(dc_pb, 1, s->interlaced_dct);
1170
if(interleaved_stats){
1171
s->misc_bits+= get_bits_diff(s);
1174
mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
1176
if(interleaved_stats){
1177
s->i_tex_bits+= get_bits_diff(s);
1181
/* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1183
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
1187
void h263_encode_mb(MpegEncContext * s,
1188
DCTELEM block[6][64],
1189
int motion_x, int motion_y)
1191
int cbpc, cbpy, i, cbp, pred_x, pred_y;
1193
int16_t rec_intradc[6];
1194
uint16_t *dc_ptr[6];
1195
const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
1196
const int dquant_code[5]= {1,0,9,2,3};
1198
//printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
1201
cbp= get_p_cbp(s, block, motion_x, motion_y);
1203
if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
1204
/* skip macroblock */
1205
put_bits(&s->pb, 1, 1);
1206
if(interleaved_stats){
1214
put_bits(&s->pb, 1, 0); /* mb coded */
1218
if(s->alt_inter_vlc==0 || cbpc!=3)
1220
if(s->dquant) cbpc+= 8;
1221
if(s->mv_type==MV_TYPE_16X16){
1223
inter_MCBPC_bits[cbpc],
1224
inter_MCBPC_code[cbpc]);
1226
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1228
put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1230
if(interleaved_stats){
1231
s->misc_bits+= get_bits_diff(s);
1234
/* motion vectors: 16x16 mode */
1235
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1238
ff_h263_encode_motion_vector(s, motion_x - pred_x,
1239
motion_y - pred_y, 1);
1242
h263p_encode_umotion(s, motion_x - pred_x);
1243
h263p_encode_umotion(s, motion_y - pred_y);
1244
if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1245
/* To prevent Start Code emulation */
1246
put_bits(&s->pb,1,1);
1250
inter_MCBPC_bits[cbpc+16],
1251
inter_MCBPC_code[cbpc+16]);
1252
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1254
put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1256
if(interleaved_stats){
1257
s->misc_bits+= get_bits_diff(s);
1261
/* motion vectors: 8x8 mode*/
1262
h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1264
motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
1265
motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1267
ff_h263_encode_motion_vector(s, motion_x - pred_x,
1268
motion_y - pred_y, 1);
1271
h263p_encode_umotion(s, motion_x - pred_x);
1272
h263p_encode_umotion(s, motion_y - pred_y);
1273
if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
1274
/* To prevent Start Code emulation */
1275
put_bits(&s->pb,1,1);
1280
if(interleaved_stats){
1281
s->mv_bits+= get_bits_diff(s);
1284
assert(s->mb_intra);
1289
for(i=0; i<6; i++) {
1290
int16_t level = block[i][0];
1293
if(i<4) scale= s->y_dc_scale;
1294
else scale= s->c_dc_scale;
1296
pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
1300
level = (level + (scale>>1))/scale;
1302
level = (level - (scale>>1))/scale;
1304
/* AIC can change CBP */
1305
if (level == 0 && s->block_last_index[i] == 0)
1306
s->block_last_index[i] = -1;
1308
if(!s->modified_quant){
1311
else if (level > 127)
1315
block[i][0] = level;
1316
/* Reconstruction */
1317
rec_intradc[i] = scale*level + pred_dc;
1319
rec_intradc[i] |= 1;
1320
//if ((rec_intradc[i] % 2) == 0)
1321
// rec_intradc[i]++;
1323
if (rec_intradc[i] < 0)
1325
else if (rec_intradc[i] > 2047)
1326
rec_intradc[i] = 2047;
1328
/* Update AC/DC tables */
1329
*dc_ptr[i] = rec_intradc[i];
1330
if (s->block_last_index[i] >= 0)
1331
cbp |= 1 << (5 - i);
1334
for(i=0; i<6; i++) {
1336
if (s->block_last_index[i] >= 1)
1337
cbp |= 1 << (5 - i);
1342
if (s->pict_type == I_TYPE) {
1343
if(s->dquant) cbpc+=4;
1345
intra_MCBPC_bits[cbpc],
1346
intra_MCBPC_code[cbpc]);
1348
if(s->dquant) cbpc+=8;
1349
put_bits(&s->pb, 1, 0); /* mb coded */
1351
inter_MCBPC_bits[cbpc + 4],
1352
inter_MCBPC_code[cbpc + 4]);
1355
/* XXX: currently, we do not try to use ac prediction */
1356
put_bits(&s->pb, 1, 0); /* no AC prediction */
1359
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
1361
put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
1363
if(interleaved_stats){
1364
s->misc_bits+= get_bits_diff(s);
1368
for(i=0; i<6; i++) {
1369
/* encode each block */
1370
h263_encode_block(s, block[i], i);
1372
/* Update INTRADC for decoding */
1373
if (s->h263_aic && s->mb_intra) {
1374
block[i][0] = rec_intradc[i];
1379
if(interleaved_stats){
1381
s->p_tex_bits+= get_bits_diff(s);
1384
s->i_tex_bits+= get_bits_diff(s);
1391
void ff_h263_loop_filter(MpegEncContext * s){
1393
const int linesize = s->linesize;
1394
const int uvlinesize= s->uvlinesize;
1395
const int xy = s->mb_y * s->mb_stride + s->mb_x;
1396
uint8_t *dest_y = s->dest[0];
1397
uint8_t *dest_cb= s->dest[1];
1398
uint8_t *dest_cr= s->dest[2];
1400
// if(s->pict_type==B_TYPE && !s->readable) return;
1406
if(!IS_SKIP(s->current_picture.mb_type[xy])){
1408
s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
1409
s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1414
int qp_dt, qp_t, qp_tc;
1416
if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
1419
qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
1427
const int chroma_qp= s->chroma_qscale_table[qp_tc];
1428
s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
1429
s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
1431
s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
1432
s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
1436
s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
1439
if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
1442
qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
1445
const int chroma_qp= s->chroma_qscale_table[qp_dt];
1446
s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
1447
s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
1448
s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1454
s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
1455
if(s->mb_y + 1 == s->mb_height)
1456
s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
1461
if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
1464
qp_lc= s->current_picture.qscale_table[xy-1];
1467
s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
1468
if(s->mb_y + 1 == s->mb_height){
1469
const int chroma_qp= s->chroma_qscale_table[qp_lc];
1470
s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
1471
s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
1472
s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
1478
static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
1480
int x, y, wrap, a, c, pred_dc, scale;
1481
int16_t *dc_val, *ac_val;
1483
/* find prediction */
1485
x = 2 * s->mb_x + (n & 1);
1486
y = 2 * s->mb_y + ((n & 2) >> 1);
1487
wrap = s->b8_stride;
1488
dc_val = s->dc_val[0];
1489
ac_val = s->ac_val[0][0];
1490
scale = s->y_dc_scale;
1494
wrap = s->mb_stride;
1495
dc_val = s->dc_val[n - 4 + 1];
1496
ac_val = s->ac_val[n - 4 + 1][0];
1497
scale = s->c_dc_scale;
1502
a = dc_val[(x - 1) + (y) * wrap];
1503
c = dc_val[(x) + (y - 1) * wrap];
1505
/* No prediction outside GOB boundary */
1506
if(s->first_slice_line && n!=3){
1508
if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1511
/* just DC prediction */
1512
if (a != 1024 && c != 1024)
1513
pred_dc = (a + c) >> 1;
1519
/* we assume pred is positive */
1520
//pred_dc = (pred_dc + (scale >> 1)) / scale;
1521
*dc_val_ptr = &dc_val[x + y * wrap];
1525
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
1527
int x, y, wrap, a, c, pred_dc, scale, i;
1528
int16_t *dc_val, *ac_val, *ac_val1;
1530
/* find prediction */
1532
x = 2 * s->mb_x + (n & 1);
1533
y = 2 * s->mb_y + (n>> 1);
1534
wrap = s->b8_stride;
1535
dc_val = s->dc_val[0];
1536
ac_val = s->ac_val[0][0];
1537
scale = s->y_dc_scale;
1541
wrap = s->mb_stride;
1542
dc_val = s->dc_val[n - 4 + 1];
1543
ac_val = s->ac_val[n - 4 + 1][0];
1544
scale = s->c_dc_scale;
1547
ac_val += ((y) * wrap + (x)) * 16;
1553
a = dc_val[(x - 1) + (y) * wrap];
1554
c = dc_val[(x) + (y - 1) * wrap];
1556
/* No prediction outside GOB boundary */
1557
if(s->first_slice_line && n!=3){
1559
if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
1564
if (s->h263_aic_dir) {
1565
/* left prediction */
1569
block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
1574
/* top prediction */
1576
ac_val -= 16 * wrap;
1578
block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
1584
/* just DC prediction */
1585
if (a != 1024 && c != 1024)
1586
pred_dc = (a + c) >> 1;
1593
/* we assume pred is positive */
1594
block[0]=block[0]*scale + pred_dc;
1601
/* Update AC/DC tables */
1602
dc_val[(x) + (y) * wrap] = block[0];
1606
ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
1609
ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
1612
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
1616
int16_t *A, *B, *C, (*mot_val)[2];
1617
static const int off[4]= {2, 1, 1, -1};
1619
wrap = s->b8_stride;
1620
mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1623
/* special case for first (slice) line */
1624
if (s->first_slice_line && block<3) {
1625
// we can't just change some MVs to simulate that as we need them for the B frames (and ME)
1626
// and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
1627
if(block==0){ //most common case
1628
if(s->mb_x == s->resync_mb_x){ //rare
1630
}else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1631
C = mot_val[off[block] - wrap];
1636
*px = mid_pred(A[0], 0, C[0]);
1637
*py = mid_pred(A[1], 0, C[1]);
1644
if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1645
C = mot_val[off[block] - wrap];
1646
*px = mid_pred(A[0], 0, C[0]);
1647
*py = mid_pred(A[1], 0, C[1]);
1652
}else{ /* block==2*/
1653
B = mot_val[ - wrap];
1654
C = mot_val[off[block] - wrap];
1655
if(s->mb_x == s->resync_mb_x) //rare
1658
*px = mid_pred(A[0], B[0], C[0]);
1659
*py = mid_pred(A[1], B[1], C[1]);
1662
B = mot_val[ - wrap];
1663
C = mot_val[off[block] - wrap];
1664
*px = mid_pred(A[0], B[0], C[0]);
1665
*py = mid_pred(A[1], B[1], C[1]);
1670
#ifdef CONFIG_ENCODERS
1671
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
1673
int range, l, bit_size, sign, code, bits;
1678
put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1680
bit_size = f_code - 1;
1681
range = 1 << bit_size;
1682
/* modulo encoding */
1683
l= INT_BIT - 6 - bit_size;
1686
val= (val^sign)-sign;
1690
code = (val >> bit_size) + 1;
1691
bits = val & (range - 1);
1693
put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1695
put_bits(&s->pb, bit_size, bits);
1700
/* Encode MV differences on H.263+ with Unrestricted MV mode */
1701
static void h263p_encode_umotion(MpegEncContext * s, int val)
1711
put_bits(&s->pb, 1, 1);
1713
put_bits(&s->pb, 3, 0);
1715
put_bits(&s->pb, 3, 2);
1718
sval = ((val < 0) ? (short)(-val):(short)val);
1721
while (temp_val != 0) {
1722
temp_val = temp_val >> 1;
1728
tcode = (sval & (1 << (i-1))) >> (i-1);
1729
tcode = (tcode << 1) | 1;
1730
code = (code << 2) | tcode;
1733
code = ((code << 1) | (val < 0)) << 1;
1734
put_bits(&s->pb, (2*n_bits)+1, code);
1735
//printf("\nVal = %d\tCode = %d", sval, code);
1739
static void init_mv_penalty_and_fcode(MpegEncContext *s)
1744
if(mv_penalty==NULL)
1745
mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
1747
for(f_code=1; f_code<=MAX_FCODE; f_code++){
1748
for(mv=-MAX_MV; mv<=MAX_MV; mv++){
1751
if(mv==0) len= mvtab[0][1];
1753
int val, bit_size, range, code;
1755
bit_size = f_code - 1;
1756
range = 1 << bit_size;
1762
code = (val >> bit_size) + 1;
1764
len= mvtab[code][1] + 1 + bit_size;
1766
len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
1770
mv_penalty[f_code][mv+MAX_MV]= len;
1774
for(f_code=MAX_FCODE; f_code>0; f_code--){
1775
for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1776
fcode_tab[mv+MAX_MV]= f_code;
1780
for(mv=0; mv<MAX_MV*2+1; mv++){
1781
umv_fcode_tab[mv]= 1;
1786
#ifdef CONFIG_ENCODERS
1788
static void init_uni_dc_tab(void)
1790
int level, uni_code, uni_len;
1792
for(level=-256; level<256; level++){
1794
/* find number of bits */
1803
l= (-level) ^ ((1 << size) - 1);
1808
uni_code= DCtab_lum[size][0];
1809
uni_len = DCtab_lum[size][1];
1812
uni_code<<=size; uni_code|=l;
1815
uni_code<<=1; uni_code|=1;
1819
uni_DCtab_lum_bits[level+256]= uni_code;
1820
uni_DCtab_lum_len [level+256]= uni_len;
1823
uni_code= DCtab_chrom[size][0];
1824
uni_len = DCtab_chrom[size][1];
1827
uni_code<<=size; uni_code|=l;
1830
uni_code<<=1; uni_code|=1;
1834
uni_DCtab_chrom_bits[level+256]= uni_code;
1835
uni_DCtab_chrom_len [level+256]= uni_len;
1840
#endif //CONFIG_ENCODERS
1842
#ifdef CONFIG_ENCODERS
1843
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1844
int slevel, run, last;
1846
assert(MAX_LEVEL >= 64);
1847
assert(MAX_RUN >= 63);
1849
for(slevel=-64; slevel<64; slevel++){
1850
if(slevel==0) continue;
1851
for(run=0; run<64; run++){
1852
for(last=0; last<=1; last++){
1853
const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1854
int level= slevel < 0 ? -slevel : slevel;
1855
int sign= slevel < 0 ? 1 : 0;
1856
int bits, len, code;
1859
len_tab[index]= 100;
1862
code= get_rl_index(rl, last, run, level);
1863
bits= rl->table_vlc[code][0];
1864
len= rl->table_vlc[code][1];
1865
bits=bits*2+sign; len++;
1867
if(code!=rl->n && len < len_tab[index]){
1868
bits_tab[index]= bits;
1869
len_tab [index]= len;
1873
bits= rl->table_vlc[rl->n][0];
1874
len= rl->table_vlc[rl->n][1];
1875
bits=bits*2; len++; //esc1
1876
level1= level - rl->max_level[last][run];
1878
code= get_rl_index(rl, last, run, level1);
1879
bits<<= rl->table_vlc[code][1];
1880
len += rl->table_vlc[code][1];
1881
bits += rl->table_vlc[code][0];
1882
bits=bits*2+sign; len++;
1884
if(code!=rl->n && len < len_tab[index]){
1885
bits_tab[index]= bits;
1886
len_tab [index]= len;
1892
bits= rl->table_vlc[rl->n][0];
1893
len= rl->table_vlc[rl->n][1];
1894
bits=bits*4+2; len+=2; //esc2
1895
run1 = run - rl->max_run[last][level] - 1;
1897
code= get_rl_index(rl, last, run1, level);
1898
bits<<= rl->table_vlc[code][1];
1899
len += rl->table_vlc[code][1];
1900
bits += rl->table_vlc[code][0];
1901
bits=bits*2+sign; len++;
1903
if(code!=rl->n && len < len_tab[index]){
1904
bits_tab[index]= bits;
1905
len_tab [index]= len;
1910
bits= rl->table_vlc[rl->n][0];
1911
len = rl->table_vlc[rl->n][1];
1912
bits=bits*4+3; len+=2; //esc3
1913
bits=bits*2+last; len++;
1914
bits=bits*64+run; len+=6;
1915
bits=bits*2+1; len++; //marker
1916
bits=bits*4096+(slevel&0xfff); len+=12;
1917
bits=bits*2+1; len++; //marker
1919
if(len < len_tab[index]){
1920
bits_tab[index]= bits;
1921
len_tab [index]= len;
1928
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1929
int slevel, run, last;
1931
assert(MAX_LEVEL >= 64);
1932
assert(MAX_RUN >= 63);
1934
for(slevel=-64; slevel<64; slevel++){
1935
if(slevel==0) continue;
1936
for(run=0; run<64; run++){
1937
for(last=0; last<=1; last++){
1938
const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1939
int level= slevel < 0 ? -slevel : slevel;
1940
int sign= slevel < 0 ? 1 : 0;
1941
int bits, len, code;
1943
len_tab[index]= 100;
1946
code= get_rl_index(rl, last, run, level);
1947
bits= rl->table_vlc[code][0];
1948
len= rl->table_vlc[code][1];
1949
bits=bits*2+sign; len++;
1951
if(code!=rl->n && len < len_tab[index]){
1952
if(bits_tab) bits_tab[index]= bits;
1953
len_tab [index]= len;
1956
bits= rl->table_vlc[rl->n][0];
1957
len = rl->table_vlc[rl->n][1];
1958
bits=bits*2+last; len++;
1959
bits=bits*64+run; len+=6;
1960
bits=bits*256+(level&0xff); len+=8;
1962
if(len < len_tab[index]){
1963
if(bits_tab) bits_tab[index]= bits;
1964
len_tab [index]= len;
1971
void h263_encode_init(MpegEncContext *s)
1973
static int done = 0;
1980
init_rl(&rl_inter, 1);
1981
init_rl(&rl_intra, 1);
1982
init_rl(&rl_intra_aic, 1);
1984
init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
1985
init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
1987
init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
1988
init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
1990
init_mv_penalty_and_fcode(s);
1992
s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1994
s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
1995
s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1997
s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
1998
s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
2000
s->ac_esc_length= 7+1+6+8;
2002
// use fcodes >1 only for mpeg4 & h263 & h263p FIXME
2003
switch(s->codec_id){
2004
case CODEC_ID_MPEG4:
2005
s->fcode_tab= fcode_tab;
2006
s->min_qcoeff= -2048;
2007
s->max_qcoeff= 2047;
2008
s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
2009
s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
2010
s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
2011
s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
2012
s->luma_dc_vlc_length= uni_DCtab_lum_len;
2013
s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
2014
s->ac_esc_length= 7+2+1+6+1+12+1;
2015
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
2016
s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
2018
if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
2020
s->avctx->extradata= av_malloc(1024);
2021
init_put_bits(&s->pb, s->avctx->extradata, 1024);
2023
if(!(s->workaround_bugs & FF_BUG_MS))
2024
mpeg4_encode_visual_object_header(s);
2025
mpeg4_encode_vol_header(s, 0, 0);
2027
// ff_mpeg4_stuffing(&s->pb); ?
2028
flush_put_bits(&s->pb);
2029
s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
2033
case CODEC_ID_H263P:
2035
s->fcode_tab= umv_fcode_tab;
2036
if(s->modified_quant){
2037
s->min_qcoeff= -2047;
2038
s->max_qcoeff= 2047;
2040
s->min_qcoeff= -127;
2044
//Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
2046
if (s->h263_flv > 1) {
2047
s->min_qcoeff= -1023;
2048
s->max_qcoeff= 1023;
2050
s->min_qcoeff= -127;
2053
s->y_dc_scale_table=
2054
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2056
default: //nothing needed - default table already set in mpegvideo.c
2057
s->min_qcoeff= -127;
2059
s->y_dc_scale_table=
2060
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
2065
* encodes a 8x8 block.
2066
* @param block the 8x8 block
2067
* @param n block index (0-3 are luma, 4-5 are chroma)
2069
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
2071
int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
2075
if (s->mb_intra && !s->h263_aic) {
2078
/* 255 cannot be represented, so we clamp */
2083
/* 0 cannot be represented also */
2084
else if (level < 1) {
2088
if (level == 128) //FIXME check rv10
2089
put_bits(&s->pb, 8, 0xff);
2091
put_bits(&s->pb, 8, level);
2095
if (s->h263_aic && s->mb_intra)
2098
if(s->alt_inter_vlc && !s->mb_intra){
2100
int inter_vlc_bits=0;
2104
last_index = s->block_last_index[n];
2105
last_non_zero = i - 1;
2106
for (; i <= last_index; i++) {
2107
j = s->intra_scantable.permutated[i];
2110
run = i - last_non_zero - 1;
2111
last = (i == last_index);
2113
if(level<0) level= -level;
2115
code = get_rl_index(rl, last, run, level);
2116
aic_code = get_rl_index(&rl_intra_aic, last, run, level);
2117
inter_vlc_bits += rl->table_vlc[code][1]+1;
2118
aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
2120
if (code == rl->n) {
2121
inter_vlc_bits += 1+6+8-1;
2123
if (aic_code == rl_intra_aic.n) {
2124
aic_vlc_bits += 1+6+8-1;
2125
wrong_pos += run + 1;
2127
wrong_pos += wrong_run[aic_code];
2132
if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
2138
last_index = s->block_last_index[n];
2139
last_non_zero = i - 1;
2140
for (; i <= last_index; i++) {
2141
j = s->intra_scantable.permutated[i];
2144
run = i - last_non_zero - 1;
2145
last = (i == last_index);
2152
code = get_rl_index(rl, last, run, level);
2153
put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2154
if (code == rl->n) {
2155
if(s->h263_flv <= 1){
2156
put_bits(&s->pb, 1, last);
2157
put_bits(&s->pb, 6, run);
2159
assert(slevel != 0);
2162
put_bits(&s->pb, 8, slevel & 0xff);
2164
put_bits(&s->pb, 8, 128);
2165
put_bits(&s->pb, 5, slevel & 0x1f);
2166
put_bits(&s->pb, 6, (slevel>>5)&0x3f);
2169
if(level < 64) { // 7-bit level
2170
put_bits(&s->pb, 1, 0);
2171
put_bits(&s->pb, 1, last);
2172
put_bits(&s->pb, 6, run);
2174
put_bits(&s->pb, 7, slevel & 0x7f);
2177
put_bits(&s->pb, 1, 1);
2178
put_bits(&s->pb, 1, last);
2179
put_bits(&s->pb, 6, run);
2181
put_bits(&s->pb, 11, slevel & 0x7ff);
2185
put_bits(&s->pb, 1, sign);
2193
#ifdef CONFIG_ENCODERS
2195
/***************************************************/
2197
* add mpeg4 stuffing bits (01...1)
2199
void ff_mpeg4_stuffing(PutBitContext * pbc)
2202
put_bits(pbc, 1, 0);
2203
length= (-put_bits_count(pbc))&7;
2204
if(length) put_bits(pbc, length, (1<<length)-1);
2207
/* must be called before writing the header */
2208
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
2209
int time_div, time_mod;
2211
assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
2212
s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
2214
time_div= s->time/s->avctx->time_base.den;
2215
time_mod= s->time%s->avctx->time_base.den;
2217
if(s->pict_type==B_TYPE){
2218
s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2219
assert(s->pb_time > 0 && s->pb_time < s->pp_time);
2221
s->last_time_base= s->time_base;
2222
s->time_base= time_div;
2223
s->pp_time= s->time - s->last_non_b_time;
2224
s->last_non_b_time= s->time;
2225
assert(picture_number==0 || s->pp_time > 0);
2229
static void mpeg4_encode_gop_header(MpegEncContext * s){
2230
int hours, minutes, seconds;
2233
put_bits(&s->pb, 16, 0);
2234
put_bits(&s->pb, 16, GOP_STARTCODE);
2236
time= s->current_picture_ptr->pts;
2237
if(s->reordered_input_picture[1])
2238
time= FFMIN(time, s->reordered_input_picture[1]->pts);
2239
time= time*s->avctx->time_base.num;
2241
seconds= time/s->avctx->time_base.den;
2242
minutes= seconds/60; seconds %= 60;
2243
hours= minutes/60; minutes %= 60;
2246
put_bits(&s->pb, 5, hours);
2247
put_bits(&s->pb, 6, minutes);
2248
put_bits(&s->pb, 1, 1);
2249
put_bits(&s->pb, 6, seconds);
2251
put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
2252
put_bits(&s->pb, 1, 0); //broken link == NO
2254
s->last_time_base= time / s->avctx->time_base.den;
2256
ff_mpeg4_stuffing(&s->pb);
2259
static void mpeg4_encode_visual_object_header(MpegEncContext * s){
2260
int profile_and_level_indication;
2263
if(s->avctx->profile != FF_PROFILE_UNKNOWN){
2264
profile_and_level_indication = s->avctx->profile << 4;
2265
}else if(s->max_b_frames || s->quarter_sample){
2266
profile_and_level_indication= 0xF0; // adv simple
2268
profile_and_level_indication= 0x00; // simple
2271
if(s->avctx->level != FF_LEVEL_UNKNOWN){
2272
profile_and_level_indication |= s->avctx->level;
2274
profile_and_level_indication |= 1; //level 1
2277
if(profile_and_level_indication>>4 == 0xF){
2285
put_bits(&s->pb, 16, 0);
2286
put_bits(&s->pb, 16, VOS_STARTCODE);
2288
put_bits(&s->pb, 8, profile_and_level_indication);
2290
put_bits(&s->pb, 16, 0);
2291
put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
2293
put_bits(&s->pb, 1, 1);
2294
put_bits(&s->pb, 4, vo_ver_id);
2295
put_bits(&s->pb, 3, 1); //priority
2297
put_bits(&s->pb, 4, 1); //visual obj type== video obj
2299
put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
2301
ff_mpeg4_stuffing(&s->pb);
2304
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
2308
if(s->max_b_frames || s->quarter_sample){
2310
s->vo_type= ADV_SIMPLE_VO_TYPE;
2313
s->vo_type= SIMPLE_VO_TYPE;
2316
put_bits(&s->pb, 16, 0);
2317
put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
2318
put_bits(&s->pb, 16, 0);
2319
put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
2321
put_bits(&s->pb, 1, 0); /* random access vol */
2322
put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
2323
if(s->workaround_bugs & FF_BUG_MS) {
2324
put_bits(&s->pb, 1, 0); /* is obj layer id= no */
2326
put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
2327
put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
2328
put_bits(&s->pb, 3, 1); /* is obj layer priority */
2331
aspect_to_info(s, s->avctx->sample_aspect_ratio);
2333
put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
2334
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
2335
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
2336
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
2339
if(s->workaround_bugs & FF_BUG_MS) { //
2340
put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
2342
put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
2343
put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
2344
put_bits(&s->pb, 1, s->low_delay);
2345
put_bits(&s->pb, 1, 0); /* vbv parameters= no */
2348
put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
2349
put_bits(&s->pb, 1, 1); /* marker bit */
2351
put_bits(&s->pb, 16, s->avctx->time_base.den);
2352
if (s->time_increment_bits < 1)
2353
s->time_increment_bits = 1;
2354
put_bits(&s->pb, 1, 1); /* marker bit */
2355
put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
2356
put_bits(&s->pb, 1, 1); /* marker bit */
2357
put_bits(&s->pb, 13, s->width); /* vol width */
2358
put_bits(&s->pb, 1, 1); /* marker bit */
2359
put_bits(&s->pb, 13, s->height); /* vol height */
2360
put_bits(&s->pb, 1, 1); /* marker bit */
2361
put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
2362
put_bits(&s->pb, 1, 1); /* obmc disable */
2363
if (vo_ver_id == 1) {
2364
put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
2366
put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
2369
put_bits(&s->pb, 1, 0); /* not 8 bit == false */
2370
put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
2373
ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
2374
ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
2378
put_bits(&s->pb, 1, s->quarter_sample);
2379
put_bits(&s->pb, 1, 1); /* complexity estimation disable */
2380
s->resync_marker= s->rtp_mode;
2381
put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
2382
put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
2383
if(s->data_partitioning){
2384
put_bits(&s->pb, 1, 0); /* no rvlc */
2387
if (vo_ver_id != 1){
2388
put_bits(&s->pb, 1, 0); /* newpred */
2389
put_bits(&s->pb, 1, 0); /* reduced res vop */
2391
put_bits(&s->pb, 1, 0); /* scalability */
2393
ff_mpeg4_stuffing(&s->pb);
2396
if(!(s->flags & CODEC_FLAG_BITEXACT)){
2397
put_bits(&s->pb, 16, 0);
2398
put_bits(&s->pb, 16, 0x1B2); /* user_data */
2399
ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
2403
/* write mpeg4 VOP header */
2404
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
2407
int time_div, time_mod;
2409
if(s->pict_type==I_TYPE){
2410
if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
2411
if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy
2412
mpeg4_encode_visual_object_header(s);
2413
if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy
2414
mpeg4_encode_vol_header(s, 0, 0);
2416
if(!(s->workaround_bugs & FF_BUG_MS))
2417
mpeg4_encode_gop_header(s);
2420
s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
2422
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
2424
put_bits(&s->pb, 16, 0); /* vop header */
2425
put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
2426
put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
2429
time_div= s->time/s->avctx->time_base.den;
2430
time_mod= s->time%s->avctx->time_base.den;
2431
time_incr= time_div - s->last_time_base;
2432
assert(time_incr >= 0);
2434
put_bits(&s->pb, 1, 1);
2436
put_bits(&s->pb, 1, 0);
2438
put_bits(&s->pb, 1, 1); /* marker */
2439
put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
2440
put_bits(&s->pb, 1, 1); /* marker */
2441
put_bits(&s->pb, 1, 1); /* vop coded */
2442
if ( s->pict_type == P_TYPE
2443
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
2444
put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
2446
put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
2447
if(!s->progressive_sequence){
2448
put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
2449
put_bits(&s->pb, 1, s->alternate_scan);
2451
//FIXME sprite stuff
2453
put_bits(&s->pb, 5, s->qscale);
2455
if (s->pict_type != I_TYPE)
2456
put_bits(&s->pb, 3, s->f_code); /* fcode_for */
2457
if (s->pict_type == B_TYPE)
2458
put_bits(&s->pb, 3, s->b_code); /* fcode_back */
2459
// printf("****frame %d\n", picture_number);
2462
#endif //CONFIG_ENCODERS
2465
* set qscale and update qscale dependant variables.
2467
void ff_set_qscale(MpegEncContext * s, int qscale)
2471
else if (qscale > 31)
2475
s->chroma_qscale= s->chroma_qscale_table[qscale];
2477
s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2478
s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2483
* encoding quantized level -> quantized diff
2484
* decoding quantized diff -> quantized level
2485
* @param n block index (0-3 are luma, 4-5 are chroma)
2486
* @param dir_ptr pointer to an integer where the prediction direction will be stored
2488
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
2490
int a, b, c, wrap, pred, scale, ret;
2493
/* find prediction */
2495
scale = s->y_dc_scale;
2497
scale = s->c_dc_scale;
2502
wrap= s->block_wrap[n];
2503
dc_val = s->dc_val[0] + s->block_index[n];
2509
b = dc_val[ - 1 - wrap];
2510
c = dc_val[ - wrap];
2512
/* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
2513
if(s->first_slice_line && n!=3){
2515
if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
2517
if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
2518
if(n==0 || n==4 || n==5)
2522
if (abs(a - b) < abs(b - c)) {
2524
*dir_ptr = 1; /* top */
2527
*dir_ptr = 0; /* left */
2529
/* we assume pred is positive */
2530
pred = FASTDIV((pred + (scale >> 1)), scale);
2537
if(s->error_resilience>=3){
2539
av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
2542
if(level*scale > 2048 + scale){
2543
av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
2552
else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
2562
* @param n block index (0-3 are luma, 4-5 are chroma)
2563
* @param dir the ac prediction direction
2565
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
2569
int16_t *ac_val, *ac_val1;
2570
int8_t * const qscale_table= s->current_picture.qscale_table;
2572
/* find prediction */
2573
ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2577
const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
2578
/* left prediction */
2581
if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
2584
block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
2587
/* different qscale, we must rescale */
2589
block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
2593
const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
2594
/* top prediction */
2595
ac_val -= 16 * s->block_wrap[n];
2597
if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
2600
block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
2603
/* different qscale, we must rescale */
2605
block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
2612
ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
2616
ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
2620
#ifdef CONFIG_ENCODERS
2623
* encodes the dc value.
2624
* @param n block index (0-3 are luma, 4-5 are chroma)
2626
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
2629
// if(level<-255 || level>255) printf("dc overflow\n");
2633
put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
2636
put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
2640
/* find number of bits */
2650
put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
2653
put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
2656
/* encode remaining bits */
2659
level = (-level) ^ ((1 << size) - 1);
2660
put_bits(&s->pb, size, level);
2662
put_bits(&s->pb, 1, 1);
2667
static inline int mpeg4_get_dc_length(int level, int n){
2669
return uni_DCtab_lum_len[level + 256];
2671
return uni_DCtab_chrom_len[level + 256];
2676
* encodes a 8x8 block
2677
* @param n block index (0-3 are luma, 4-5 are chroma)
2679
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2680
uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
2682
int i, last_non_zero;
2683
#if 0 //variables for the outcommented version
2684
int code, sign, last;
2689
const int last_index = s->block_last_index[n];
2691
if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2692
/* mpeg4 based DC predictor */
2693
mpeg4_encode_dc(dc_pb, intra_dc, n);
2694
if(last_index<1) return;
2697
bits_tab= uni_mpeg4_intra_rl_bits;
2698
len_tab = uni_mpeg4_intra_rl_len;
2700
if(last_index<0) return;
2703
bits_tab= uni_mpeg4_inter_rl_bits;
2704
len_tab = uni_mpeg4_inter_rl_len;
2708
last_non_zero = i - 1;
2710
for (; i < last_index; i++) {
2711
int level = block[ scan_table[i] ];
2713
int run = i - last_non_zero - 1;
2715
if((level&(~127)) == 0){
2716
const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2717
put_bits(ac_pb, len_tab[index], bits_tab[index]);
2719
put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2724
/*if(i<=last_index)*/{
2725
int level = block[ scan_table[i] ];
2726
int run = i - last_non_zero - 1;
2728
if((level&(~127)) == 0){
2729
const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2730
put_bits(ac_pb, len_tab[index], bits_tab[index]);
2732
put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
2736
for (; i <= last_index; i++) {
2737
const int slevel = block[ scan_table[i] ];
2740
int run = i - last_non_zero - 1;
2741
last = (i == last_index);
2748
code = get_rl_index(rl, last, run, level);
2749
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2750
if (code == rl->n) {
2752
level1 = level - rl->max_level[last][run];
2755
code = get_rl_index(rl, last, run, level1);
2756
if (code == rl->n) {
2758
put_bits(ac_pb, 1, 1);
2759
if (level > MAX_LEVEL)
2761
run1 = run - rl->max_run[last][level] - 1;
2764
code = get_rl_index(rl, last, run1, level);
2765
if (code == rl->n) {
2768
put_bits(ac_pb, 1, 1);
2769
put_bits(ac_pb, 1, last);
2770
put_bits(ac_pb, 6, run);
2771
put_bits(ac_pb, 1, 1);
2772
put_bits(ac_pb, 12, slevel & 0xfff);
2773
put_bits(ac_pb, 1, 1);
2776
put_bits(ac_pb, 1, 0);
2777
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2778
put_bits(ac_pb, 1, sign);
2782
put_bits(ac_pb, 1, 0);
2783
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
2784
put_bits(ac_pb, 1, sign);
2787
put_bits(ac_pb, 1, sign);
2795
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
2796
uint8_t *scan_table)
2798
int i, last_non_zero;
2801
const int last_index = s->block_last_index[n];
2804
if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
2805
/* mpeg4 based DC predictor */
2806
len += mpeg4_get_dc_length(intra_dc, n);
2807
if(last_index<1) return len;
2810
len_tab = uni_mpeg4_intra_rl_len;
2812
if(last_index<0) return 0;
2815
len_tab = uni_mpeg4_inter_rl_len;
2819
last_non_zero = i - 1;
2820
for (; i < last_index; i++) {
2821
int level = block[ scan_table[i] ];
2823
int run = i - last_non_zero - 1;
2825
if((level&(~127)) == 0){
2826
const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
2827
len += len_tab[index];
2829
len += 7+2+1+6+1+12+1;
2834
/*if(i<=last_index)*/{
2835
int level = block[ scan_table[i] ];
2836
int run = i - last_non_zero - 1;
2838
if((level&(~127)) == 0){
2839
const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
2840
len += len_tab[index];
2842
len += 7+2+1+6+1+12+1;
2852
/***********************************************/
2855
static VLC intra_MCBPC_vlc;
2856
static VLC inter_MCBPC_vlc;
2857
static VLC cbpy_vlc;
2859
static VLC dc_lum, dc_chrom;
2860
static VLC sprite_trajectory;
2861
static VLC mb_type_b_vlc;
2862
static VLC h263_mbtype_b_vlc;
2863
static VLC cbpc_b_vlc;
2865
void init_vlc_rl(RLTable *rl, int use_static)
2869
/* Return if static table is already initialized */
2870
if(use_static && rl->rl_vlc[0])
2873
init_vlc(&rl->vlc, 9, rl->n + 1,
2874
&rl->table_vlc[0][1], 4, 2,
2875
&rl->table_vlc[0][0], 4, 2, use_static);
2878
for(q=0; q<32; q++){
2887
rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2889
rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
2890
for(i=0; i<rl->vlc.table_size; i++){
2891
int code= rl->vlc.table[i][0];
2892
int len = rl->vlc.table[i][1];
2895
if(len==0){ // illegal code
2898
}else if(len<0){ //more bits needed
2902
if(code==rl->n){ //esc
2906
run= rl->table_run [code] + 1;
2907
level= rl->table_level[code] * qmul + qadd;
2908
if(code >= rl->last) run+=192;
2911
rl->rl_vlc[q][i].len= len;
2912
rl->rl_vlc[q][i].level= level;
2913
rl->rl_vlc[q][i].run= run;
2920
/* XXX: find a better solution to handle static init */
2921
void h263_decode_init_vlc(MpegEncContext *s)
2923
static int done = 0;
2928
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
2929
intra_MCBPC_bits, 1, 1,
2930
intra_MCBPC_code, 1, 1, 1);
2931
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
2932
inter_MCBPC_bits, 1, 1,
2933
inter_MCBPC_code, 1, 1, 1);
2934
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
2935
&cbpy_tab[0][1], 2, 1,
2936
&cbpy_tab[0][0], 2, 1, 1);
2937
init_vlc(&mv_vlc, MV_VLC_BITS, 33,
2939
&mvtab[0][0], 2, 1, 1);
2940
init_rl(&rl_inter, 1);
2941
init_rl(&rl_intra, 1);
2942
init_rl(&rvlc_rl_inter, 1);
2943
init_rl(&rvlc_rl_intra, 1);
2944
init_rl(&rl_intra_aic, 1);
2945
init_vlc_rl(&rl_inter, 1);
2946
init_vlc_rl(&rl_intra, 1);
2947
init_vlc_rl(&rvlc_rl_inter, 1);
2948
init_vlc_rl(&rvlc_rl_intra, 1);
2949
init_vlc_rl(&rl_intra_aic, 1);
2950
init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
2951
&DCtab_lum[0][1], 2, 1,
2952
&DCtab_lum[0][0], 2, 1, 1);
2953
init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
2954
&DCtab_chrom[0][1], 2, 1,
2955
&DCtab_chrom[0][0], 2, 1, 1);
2956
init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
2957
&sprite_trajectory_tab[0][1], 4, 2,
2958
&sprite_trajectory_tab[0][0], 4, 2, 1);
2959
init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
2960
&mb_type_b_tab[0][1], 2, 1,
2961
&mb_type_b_tab[0][0], 2, 1, 1);
2962
init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
2963
&h263_mbtype_b_tab[0][1], 2, 1,
2964
&h263_mbtype_b_tab[0][0], 2, 1, 1);
2965
init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
2966
&cbpc_b_tab[0][1], 2, 1,
2967
&cbpc_b_tab[0][0], 2, 1, 1);
2972
* Get the GOB height based on picture height.
2974
int ff_h263_get_gob_height(MpegEncContext *s){
2975
if (s->height <= 400)
2977
else if (s->height <= 800)
2983
int ff_h263_decode_mba(MpegEncContext *s)
2988
if(s->mb_num-1 <= ff_mba_max[i]) break;
2990
mb_pos= get_bits(&s->gb, ff_mba_length[i]);
2991
s->mb_x= mb_pos % s->mb_width;
2992
s->mb_y= mb_pos / s->mb_width;
2997
void ff_h263_encode_mba(MpegEncContext *s)
3002
if(s->mb_num-1 <= ff_mba_max[i]) break;
3004
mb_pos= s->mb_x + s->mb_width*s->mb_y;
3005
put_bits(&s->pb, ff_mba_length[i], mb_pos);
3009
* decodes the group of blocks header or slice header.
3010
* @return <0 if an error occured
3012
static int h263_decode_gob_header(MpegEncContext *s)
3014
unsigned int val, gfid, gob_number;
3017
/* Check for GOB Start Code */
3018
val = show_bits(&s->gb, 16);
3022
/* We have a GBSC probably with GSTUFF */
3023
skip_bits(&s->gb, 16); /* Drop the zeros */
3024
left= s->gb.size_in_bits - get_bits_count(&s->gb);
3025
//MN: we must check the bits left or we might end in a infinite loop (or segfault)
3026
for(;left>13; left--){
3027
if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
3032
if(s->h263_slice_structured){
3033
if(get_bits1(&s->gb)==0)
3036
ff_h263_decode_mba(s);
3038
if(s->mb_num > 1583)
3039
if(get_bits1(&s->gb)==0)
3042
s->qscale = get_bits(&s->gb, 5); /* SQUANT */
3043
if(get_bits1(&s->gb)==0)
3045
gfid = get_bits(&s->gb, 2); /* GFID */
3047
gob_number = get_bits(&s->gb, 5); /* GN */
3049
s->mb_y= s->gob_index* gob_number;
3050
gfid = get_bits(&s->gb, 2); /* GFID */
3051
s->qscale = get_bits(&s->gb, 5); /* GQUANT */
3054
if(s->mb_y >= s->mb_height)
3063
static inline void memsetw(short *tab, int val, int n)
3070
#ifdef CONFIG_ENCODERS
3072
void ff_mpeg4_init_partitions(MpegEncContext *s)
3074
uint8_t *start= pbBufPtr(&s->pb);
3075
uint8_t *end= s->pb.buf_end;
3076
int size= end - start;
3077
int pb_size = (((long)start + size/3)&(~3)) - (long)start;
3078
int tex_size= (size - 2*pb_size)&(~3);
3080
set_put_bits_buffer_size(&s->pb, pb_size);
3081
init_put_bits(&s->tex_pb, start + pb_size , tex_size);
3082
init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
3085
void ff_mpeg4_merge_partitions(MpegEncContext *s)
3087
const int pb2_len = put_bits_count(&s->pb2 );
3088
const int tex_pb_len= put_bits_count(&s->tex_pb);
3089
const int bits= put_bits_count(&s->pb);
3091
if(s->pict_type==I_TYPE){
3092
put_bits(&s->pb, 19, DC_MARKER);
3093
s->misc_bits+=19 + pb2_len + bits - s->last_bits;
3094
s->i_tex_bits+= tex_pb_len;
3096
put_bits(&s->pb, 17, MOTION_MARKER);
3097
s->misc_bits+=17 + pb2_len;
3098
s->mv_bits+= bits - s->last_bits;
3099
s->p_tex_bits+= tex_pb_len;
3102
flush_put_bits(&s->pb2);
3103
flush_put_bits(&s->tex_pb);
3105
set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
3106
ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
3107
ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
3108
s->last_bits= put_bits_count(&s->pb);
3111
#endif //CONFIG_ENCODERS
3113
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
3114
switch(s->pict_type){
3119
return s->f_code+15;
3121
return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
3127
#ifdef CONFIG_ENCODERS
3129
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
3131
int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3133
put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
3134
put_bits(&s->pb, 1, 1);
3136
put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
3137
put_bits(&s->pb, s->quant_precision, s->qscale);
3138
put_bits(&s->pb, 1, 0); /* no HEC */
3141
#endif //CONFIG_ENCODERS
3144
* check if the next stuff is a resync marker or the end.
3147
static inline int mpeg4_is_resync(MpegEncContext *s){
3148
const int bits_count= get_bits_count(&s->gb);
3150
if(s->workaround_bugs&FF_BUG_NO_PADDING){
3154
if(bits_count + 8 >= s->gb.size_in_bits){
3155
int v= show_bits(&s->gb, 8);
3156
v|= 0x7F >> (7-(bits_count&7));
3161
if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
3163
GetBitContext gb= s->gb;
3165
skip_bits(&s->gb, 1);
3166
align_get_bits(&s->gb);
3168
for(len=0; len<32; len++){
3169
if(get_bits1(&s->gb)) break;
3174
if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
3182
* decodes the next video packet.
3183
* @return <0 if something went wrong
3185
static int mpeg4_decode_video_packet_header(MpegEncContext *s)
3187
int mb_num_bits= av_log2(s->mb_num - 1) + 1;
3188
int header_extension=0, mb_num, len;
3190
/* is there enough space left for a video packet + header */
3191
if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
3193
for(len=0; len<32; len++){
3194
if(get_bits1(&s->gb)) break;
3197
if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
3198
av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
3202
if(s->shape != RECT_SHAPE){
3203
header_extension= get_bits1(&s->gb);
3204
//FIXME more stuff here
3207
mb_num= get_bits(&s->gb, mb_num_bits);
3208
if(mb_num>=s->mb_num){
3209
av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
3212
if(s->pict_type == B_TYPE){
3213
while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
3214
if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded
3217
s->mb_x= mb_num % s->mb_width;
3218
s->mb_y= mb_num / s->mb_width;
3220
if(s->shape != BIN_ONLY_SHAPE){
3221
int qscale= get_bits(&s->gb, s->quant_precision);
3223
s->chroma_qscale=s->qscale= qscale;
3226
if(s->shape == RECT_SHAPE){
3227
header_extension= get_bits1(&s->gb);
3229
if(header_extension){
3233
while (get_bits1(&s->gb) != 0)
3236
check_marker(&s->gb, "before time_increment in video packed header");
3237
time_increment= get_bits(&s->gb, s->time_increment_bits);
3238
check_marker(&s->gb, "before vop_coding_type in video packed header");
3240
skip_bits(&s->gb, 2); /* vop coding type */
3241
//FIXME not rect stuff here
3243
if(s->shape != BIN_ONLY_SHAPE){
3244
skip_bits(&s->gb, 3); /* intra dc vlc threshold */
3245
//FIXME don't just ignore everything
3246
if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3247
mpeg4_decode_sprite_trajectory(s, &s->gb);
3248
av_log(s->avctx, AV_LOG_ERROR, "untested\n");
3251
//FIXME reduced res stuff here
3253
if (s->pict_type != I_TYPE) {
3254
int f_code = get_bits(&s->gb, 3); /* fcode_for */
3256
av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
3259
if (s->pict_type == B_TYPE) {
3260
int b_code = get_bits(&s->gb, 3);
3262
av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
3267
//FIXME new-pred stuff
3269
//printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
3274
void ff_mpeg4_clean_buffers(MpegEncContext *s)
3276
int c_wrap, c_xy, l_wrap, l_xy;
3278
l_wrap= s->b8_stride;
3279
l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
3280
c_wrap= s->mb_stride;
3281
c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
3285
memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
3286
memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
3287
memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
3291
memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
3292
memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3293
memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
3296
// we can't clear the MVs as they might be needed by a b frame
3297
// memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
3298
// memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
3299
s->last_mv[0][0][0]=
3300
s->last_mv[0][0][1]=
3301
s->last_mv[1][0][0]=
3302
s->last_mv[1][0][1]= 0;
3306
* decodes the group of blocks / video packet header.
3307
* @return <0 if no resync found
3309
int ff_h263_resync(MpegEncContext *s){
3312
if(s->codec_id==CODEC_ID_MPEG4){
3314
align_get_bits(&s->gb);
3317
if(show_bits(&s->gb, 16)==0){
3318
if(s->codec_id==CODEC_ID_MPEG4)
3319
ret= mpeg4_decode_video_packet_header(s);
3321
ret= h263_decode_gob_header(s);
3325
//ok, it's not where its supposed to be ...
3326
s->gb= s->last_resync_gb;
3327
align_get_bits(&s->gb);
3328
left= s->gb.size_in_bits - get_bits_count(&s->gb);
3330
for(;left>16+1+5+5; left-=8){
3331
if(show_bits(&s->gb, 16)==0){
3332
GetBitContext bak= s->gb;
3334
if(s->codec_id==CODEC_ID_MPEG4)
3335
ret= mpeg4_decode_video_packet_header(s);
3337
ret= h263_decode_gob_header(s);
3343
skip_bits(&s->gb, 8);
3350
* gets the average motion vector for a GMC MB.
3351
* @param n either 0 for the x component or 1 for y
3352
* @returns the average MV for a GMC MB
3354
static inline int get_amv(MpegEncContext *s, int n){
3355
int x, y, mb_v, sum, dx, dy, shift;
3356
int len = 1 << (s->f_code + 4);
3357
const int a= s->sprite_warping_accuracy;
3359
if(s->workaround_bugs & FF_BUG_AMV)
3360
len >>= s->quarter_sample;
3362
if(s->real_sprite_warping_points==1){
3363
if(s->divx_version==500 && s->divx_build==413)
3364
sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
3366
sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
3368
dx= s->sprite_delta[n][0];
3369
dy= s->sprite_delta[n][1];
3370
shift= s->sprite_shift[0];
3371
if(n) dy -= 1<<(shift + a + 1);
3372
else dx -= 1<<(shift + a + 1);
3373
mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
3376
for(y=0; y<16; y++){
3380
//XXX FIXME optimize
3381
for(x=0; x<16; x++){
3386
sum= RSHIFT(sum, a+8-s->quarter_sample);
3389
if (sum < -len) sum= -len;
3390
else if (sum >= len) sum= len-1;
3396
* decodes first partition.
3397
* @return number of MBs decoded or <0 if an error occured
3399
static int mpeg4_decode_partition_a(MpegEncContext *s){
3401
static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3403
/* decode first partition */
3405
s->first_slice_line=1;
3406
for(; s->mb_y<s->mb_height; s->mb_y++){
3407
ff_init_block_index(s);
3408
for(; s->mb_x<s->mb_width; s->mb_x++){
3409
const int xy= s->mb_x + s->mb_y*s->mb_stride;
3414
ff_update_block_index(s);
3415
if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3416
s->first_slice_line=0;
3418
if(s->pict_type==I_TYPE){
3422
if(show_bits_long(&s->gb, 19)==DC_MARKER){
3426
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
3428
av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3433
s->cbp_table[xy]= cbpc & 3;
3434
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3438
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3440
s->current_picture.qscale_table[xy]= s->qscale;
3442
s->mbintra_table[xy]= 1;
3445
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3447
av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3451
if(dc_pred_dir) dir|=1;
3453
s->pred_dir_table[xy]= dir;
3454
}else{ /* P/S_TYPE */
3455
int mx, my, pred_x, pred_y, bits;
3456
int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
3457
const int stride= s->b8_stride*2;
3460
bits= show_bits(&s->gb, 17);
3461
if(bits==MOTION_MARKER){
3467
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3468
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3472
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3475
mot_val[0 ]= mot_val[2 ]=
3476
mot_val[0+stride]= mot_val[2+stride]= mx;
3477
mot_val[1 ]= mot_val[3 ]=
3478
mot_val[1+stride]= mot_val[3+stride]= my;
3480
if(s->mbintra_table[xy])
3481
ff_clean_intra_table_entries(s);
3485
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3487
av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
3493
s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
3495
s->mb_intra = ((cbpc & 4) != 0);
3498
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3499
s->mbintra_table[xy]= 1;
3500
mot_val[0 ]= mot_val[2 ]=
3501
mot_val[0+stride]= mot_val[2+stride]= 0;
3502
mot_val[1 ]= mot_val[3 ]=
3503
mot_val[1+stride]= mot_val[3+stride]= 0;
3505
if(s->mbintra_table[xy])
3506
ff_clean_intra_table_entries(s);
3508
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
3509
s->mcsel= get_bits1(&s->gb);
3512
if ((cbpc & 16) == 0) {
3513
/* 16x16 motion prediction */
3515
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3517
mx = h263_decode_motion(s, pred_x, s->f_code);
3521
my = h263_decode_motion(s, pred_y, s->f_code);
3524
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3528
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
3531
mot_val[0 ]= mot_val[2 ] =
3532
mot_val[0+stride]= mot_val[2+stride]= mx;
3533
mot_val[1 ]= mot_val[3 ]=
3534
mot_val[1+stride]= mot_val[3+stride]= my;
3537
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3539
int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3540
mx = h263_decode_motion(s, pred_x, s->f_code);
3544
my = h263_decode_motion(s, pred_y, s->f_code);
3561
* decode second partition.
3562
* @return <0 if an error occured
3564
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
3566
static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3568
s->mb_x= s->resync_mb_x;
3569
s->first_slice_line=1;
3570
for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
3571
ff_init_block_index(s);
3572
for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
3573
const int xy= s->mb_x + s->mb_y*s->mb_stride;
3576
ff_update_block_index(s);
3577
if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
3578
s->first_slice_line=0;
3580
if(s->pict_type==I_TYPE){
3581
int ac_pred= get_bits1(&s->gb);
3582
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3584
av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3588
s->cbp_table[xy]|= cbpy<<2;
3589
s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3590
}else{ /* P || S_TYPE */
3591
if(IS_INTRA(s->current_picture.mb_type[xy])){
3593
int ac_pred = get_bits1(&s->gb);
3594
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3597
av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3601
if(s->cbp_table[xy] & 8) {
3602
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3604
s->current_picture.qscale_table[xy]= s->qscale;
3608
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
3610
av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
3614
if(dc_pred_dir) dir|=1;
3616
s->cbp_table[xy]&= 3; //remove dquant
3617
s->cbp_table[xy]|= cbpy<<2;
3618
s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
3619
s->pred_dir_table[xy]= dir;
3620
}else if(IS_SKIP(s->current_picture.mb_type[xy])){
3621
s->current_picture.qscale_table[xy]= s->qscale;
3622
s->cbp_table[xy]= 0;
3624
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3627
av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
3631
if(s->cbp_table[xy] & 8) {
3632
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
3634
s->current_picture.qscale_table[xy]= s->qscale;
3636
s->cbp_table[xy]&= 3; //remove dquant
3637
s->cbp_table[xy]|= (cbpy^0xf)<<2;
3641
if(mb_num >= mb_count) return 0;
3648
* decodes the first & second partition
3649
* @return <0 if error (and sets error type in the error_status_table)
3651
int ff_mpeg4_decode_partitions(MpegEncContext *s)
3654
const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
3655
const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
3657
mb_num= mpeg4_decode_partition_a(s);
3659
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3663
if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
3664
av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
3665
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
3669
s->mb_num_left= mb_num;
3671
if(s->pict_type==I_TYPE){
3672
while(show_bits(&s->gb, 9) == 1)
3673
skip_bits(&s->gb, 9);
3674
if(get_bits_long(&s->gb, 19)!=DC_MARKER){
3675
av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
3679
while(show_bits(&s->gb, 10) == 1)
3680
skip_bits(&s->gb, 10);
3681
if(get_bits(&s->gb, 17)!=MOTION_MARKER){
3682
av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
3686
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
3688
if( mpeg4_decode_partition_b(s, mb_num) < 0){
3689
if(s->pict_type==P_TYPE)
3690
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
3693
if(s->pict_type==P_TYPE)
3694
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
3701
* decode partition C of one MB.
3702
* @return <0 if an error occured
3704
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
3707
const int xy= s->mb_x + s->mb_y*s->mb_stride;
3709
mb_type= s->current_picture.mb_type[xy];
3710
cbp = s->cbp_table[xy];
3712
if(s->current_picture.qscale_table[xy] != s->qscale){
3713
ff_set_qscale(s, s->current_picture.qscale_table[xy] );
3716
if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
3719
s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
3720
s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
3722
s->mb_intra = IS_INTRA(mb_type);
3724
if (IS_SKIP(mb_type)) {
3727
s->block_last_index[i] = -1;
3728
s->mv_dir = MV_DIR_FORWARD;
3729
s->mv_type = MV_TYPE_16X16;
3730
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
3737
}else if(s->mb_intra){
3738
s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3739
}else if(!s->mb_intra){
3740
// s->mcsel= 0; //FIXME do we need to init that
3742
s->mv_dir = MV_DIR_FORWARD;
3743
if (IS_8X8(mb_type)) {
3744
s->mv_type = MV_TYPE_8X8;
3746
s->mv_type = MV_TYPE_16X16;
3749
} else { /* I-Frame */
3751
s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
3754
if (!IS_SKIP(mb_type)) {
3756
s->dsp.clear_blocks(s->block[0]);
3757
/* decode each block */
3758
for (i = 0; i < 6; i++) {
3759
if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
3760
av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
3767
/* per-MB end of slice check */
3769
if(--s->mb_num_left <= 0){
3770
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
3771
if(mpeg4_is_resync(s))
3776
if(mpeg4_is_resync(s)){
3777
const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
3778
if(s->cbp_table[xy+delta])
3786
* read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
3788
static void preview_obmc(MpegEncContext *s){
3789
GetBitContext gb= s->gb;
3791
int cbpc, i, pred_x, pred_y, mx, my;
3793
const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
3794
const int stride= s->b8_stride*2;
3797
s->block_index[i]+= 2;
3799
s->block_index[i]+= 1;
3802
assert(s->pict_type == P_TYPE);
3805
if (get_bits1(&s->gb)) {
3807
mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
3808
mot_val[0 ]= mot_val[2 ]=
3809
mot_val[0+stride]= mot_val[2+stride]= 0;
3810
mot_val[1 ]= mot_val[3 ]=
3811
mot_val[1+stride]= mot_val[3+stride]= 0;
3813
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3816
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3820
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
3822
get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3824
if(s->modified_quant){
3825
if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
3826
else skip_bits(&s->gb, 5);
3828
skip_bits(&s->gb, 2);
3831
if ((cbpc & 16) == 0) {
3832
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3833
/* 16x16 motion prediction */
3834
mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3836
mx = h263p_decode_umotion(s, pred_x);
3838
mx = h263_decode_motion(s, pred_x, 1);
3841
my = h263p_decode_umotion(s, pred_y);
3843
my = h263_decode_motion(s, pred_y, 1);
3845
mot_val[0 ]= mot_val[2 ]=
3846
mot_val[0+stride]= mot_val[2+stride]= mx;
3847
mot_val[1 ]= mot_val[3 ]=
3848
mot_val[1+stride]= mot_val[3+stride]= my;
3850
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3852
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3854
mx = h263p_decode_umotion(s, pred_x);
3856
mx = h263_decode_motion(s, pred_x, 1);
3859
my = h263p_decode_umotion(s, pred_y);
3861
my = h263_decode_motion(s, pred_y, 1);
3862
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3863
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3872
s->block_index[i]-= 2;
3874
s->block_index[i]-= 1;
3880
static void h263_decode_dquant(MpegEncContext *s){
3881
static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
3883
if(s->modified_quant){
3884
if(get_bits1(&s->gb))
3885
s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
3887
s->qscale= get_bits(&s->gb, 5);
3889
s->qscale += quant_tab[get_bits(&s->gb, 2)];
3890
ff_set_qscale(s, s->qscale);
3893
int ff_h263_decode_mb(MpegEncContext *s,
3894
DCTELEM block[6][64])
3896
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
3898
const int xy= s->mb_x + s->mb_y * s->mb_stride;
3900
assert(!s->h263_pred);
3902
if (s->pict_type == P_TYPE) {
3904
if (get_bits1(&s->gb)) {
3908
s->block_last_index[i] = -1;
3909
s->mv_dir = MV_DIR_FORWARD;
3910
s->mv_type = MV_TYPE_16X16;
3911
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
3914
s->mb_skipped = !(s->obmc | s->loop_filter);
3917
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
3918
//fprintf(stderr, "\tCBPC: %d", cbpc);
3920
av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
3925
s->dsp.clear_blocks(s->block[0]);
3928
s->mb_intra = ((cbpc & 4) != 0);
3929
if (s->mb_intra) goto intra;
3931
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
3933
if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
3936
cbp = (cbpc & 3) | (cbpy << 2);
3938
h263_decode_dquant(s);
3941
s->mv_dir = MV_DIR_FORWARD;
3942
if ((cbpc & 16) == 0) {
3943
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
3944
/* 16x16 motion prediction */
3945
s->mv_type = MV_TYPE_16X16;
3946
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
3948
mx = h263p_decode_umotion(s, pred_x);
3950
mx = h263_decode_motion(s, pred_x, 1);
3956
my = h263p_decode_umotion(s, pred_y);
3958
my = h263_decode_motion(s, pred_y, 1);
3962
s->mv[0][0][0] = mx;
3963
s->mv[0][0][1] = my;
3965
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3966
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3968
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
3969
s->mv_type = MV_TYPE_8X8;
3971
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
3973
mx = h263p_decode_umotion(s, pred_x);
3975
mx = h263_decode_motion(s, pred_x, 1);
3980
my = h263p_decode_umotion(s, pred_y);
3982
my = h263_decode_motion(s, pred_y, 1);
3985
s->mv[0][i][0] = mx;
3986
s->mv[0][i][1] = my;
3987
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
3988
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
3994
/* decode each block */
3995
for (i = 0; i < 6; i++) {
3996
if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4002
if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
4005
} else if(s->pict_type==B_TYPE) {
4007
const int stride= s->b8_stride;
4008
int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
4009
int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
4010
// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
4013
mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
4014
mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
4015
mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
4016
mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
4019
mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
4021
av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
4025
mb_type= h263_mb_type_b_map[ mb_type ];
4028
s->mb_intra = IS_INTRA(mb_type);
4029
if(HAS_CBP(mb_type)){
4030
s->dsp.clear_blocks(s->block[0]);
4031
cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
4033
dquant = IS_QUANT(mb_type);
4037
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4040
av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4044
if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
4047
cbp = (cbpc & 3) | (cbpy << 2);
4051
assert(!s->mb_intra);
4053
if(IS_QUANT(mb_type)){
4054
h263_decode_dquant(s);
4057
if(IS_DIRECT(mb_type)){
4058
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4059
mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
4062
s->mv_type= MV_TYPE_16X16;
4065
if(USES_LIST(mb_type, 0)){
4066
int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
4067
s->mv_dir = MV_DIR_FORWARD;
4069
mx = h263_decode_motion(s, mx, 1);
4070
my = h263_decode_motion(s, my, 1);
4072
s->mv[0][0][0] = mx;
4073
s->mv[0][0][1] = my;
4074
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4075
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4078
if(USES_LIST(mb_type, 1)){
4079
int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
4080
s->mv_dir |= MV_DIR_BACKWARD;
4082
mx = h263_decode_motion(s, mx, 1);
4083
my = h263_decode_motion(s, my, 1);
4085
s->mv[1][0][0] = mx;
4086
s->mv[1][0][1] = my;
4087
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
4088
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
4092
s->current_picture.mb_type[xy]= mb_type;
4094
/* decode each block */
4095
for (i = 0; i < 6; i++) {
4096
if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4100
} else { /* I-Frame */
4102
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4104
av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4109
s->dsp.clear_blocks(s->block[0]);
4114
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4116
s->ac_pred = get_bits1(&s->gb);
4118
s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4120
s->h263_aic_dir = get_bits1(&s->gb);
4125
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4127
av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4130
cbp = (cbpc & 3) | (cbpy << 2);
4132
h263_decode_dquant(s);
4135
/* decode each block */
4136
for (i = 0; i < 6; i++) {
4137
if (h263_decode_block(s, block[i], i, cbp&32) < 0)
4144
/* per-MB end of slice check */
4146
int v= show_bits(&s->gb, 16);
4148
if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
4149
v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
4159
int ff_mpeg4_decode_mb(MpegEncContext *s,
4160
DCTELEM block[6][64])
4162
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
4164
static int8_t quant_tab[4] = { -1, -2, 1, 2 };
4165
const int xy= s->mb_x + s->mb_y * s->mb_stride;
4167
assert(s->h263_pred);
4169
if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
4171
if (get_bits1(&s->gb)) {
4175
s->block_last_index[i] = -1;
4176
s->mv_dir = MV_DIR_FORWARD;
4177
s->mv_type = MV_TYPE_16X16;
4178
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
4179
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4181
s->mv[0][0][0]= get_amv(s, 0);
4182
s->mv[0][0][1]= get_amv(s, 1);
4186
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4194
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
4195
//fprintf(stderr, "\tCBPC: %d", cbpc);
4197
av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4202
s->dsp.clear_blocks(s->block[0]);
4204
s->mb_intra = ((cbpc & 4) != 0);
4205
if (s->mb_intra) goto intra;
4207
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
4208
s->mcsel= get_bits1(&s->gb);
4210
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
4212
cbp = (cbpc & 3) | (cbpy << 2);
4214
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4216
if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
4217
s->interlaced_dct= get_bits1(&s->gb);
4219
s->mv_dir = MV_DIR_FORWARD;
4220
if ((cbpc & 16) == 0) {
4222
s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
4223
/* 16x16 global motion prediction */
4224
s->mv_type = MV_TYPE_16X16;
4227
s->mv[0][0][0] = mx;
4228
s->mv[0][0][1] = my;
4229
}else if((!s->progressive_sequence) && get_bits1(&s->gb)){
4230
s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
4231
/* 16x8 field motion prediction */
4232
s->mv_type= MV_TYPE_FIELD;
4234
s->field_select[0][0]= get_bits1(&s->gb);
4235
s->field_select[0][1]= get_bits1(&s->gb);
4237
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4240
mx = h263_decode_motion(s, pred_x, s->f_code);
4244
my = h263_decode_motion(s, pred_y/2, s->f_code);
4248
s->mv[0][i][0] = mx;
4249
s->mv[0][i][1] = my;
4252
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
4253
/* 16x16 motion prediction */
4254
s->mv_type = MV_TYPE_16X16;
4255
h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
4256
mx = h263_decode_motion(s, pred_x, s->f_code);
4261
my = h263_decode_motion(s, pred_y, s->f_code);
4265
s->mv[0][0][0] = mx;
4266
s->mv[0][0][1] = my;
4269
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
4270
s->mv_type = MV_TYPE_8X8;
4272
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
4273
mx = h263_decode_motion(s, pred_x, s->f_code);
4277
my = h263_decode_motion(s, pred_y, s->f_code);
4280
s->mv[0][i][0] = mx;
4281
s->mv[0][i][1] = my;
4286
} else if(s->pict_type==B_TYPE) {
4287
int modb1; // first bit of modb
4288
int modb2; // second bit of modb
4291
s->mb_intra = 0; //B-frames never contain intra blocks
4292
s->mcsel=0; // ... true gmc blocks
4296
s->last_mv[i][0][0]=
4297
s->last_mv[i][0][1]=
4298
s->last_mv[i][1][0]=
4299
s->last_mv[i][1][1]= 0;
4303
/* if we skipped it in the future P Frame than skip it now too */
4304
s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
4309
s->block_last_index[i] = -1;
4311
s->mv_dir = MV_DIR_FORWARD;
4312
s->mv_type = MV_TYPE_16X16;
4317
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
4321
modb1= get_bits1(&s->gb);
4323
mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
4326
modb2= get_bits1(&s->gb);
4327
mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
4329
av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
4332
mb_type= mb_type_b_map[ mb_type ];
4335
s->dsp.clear_blocks(s->block[0]);
4336
cbp= get_bits(&s->gb, 6);
4339
if ((!IS_DIRECT(mb_type)) && cbp) {
4340
if(get_bits1(&s->gb)){
4341
ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
4345
if(!s->progressive_sequence){
4347
s->interlaced_dct= get_bits1(&s->gb);
4349
if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
4350
mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
4351
mb_type &= ~MB_TYPE_16x16;
4353
if(USES_LIST(mb_type, 0)){
4354
s->field_select[0][0]= get_bits1(&s->gb);
4355
s->field_select[0][1]= get_bits1(&s->gb);
4357
if(USES_LIST(mb_type, 1)){
4358
s->field_select[1][0]= get_bits1(&s->gb);
4359
s->field_select[1][1]= get_bits1(&s->gb);
4365
if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
4366
s->mv_type= MV_TYPE_16X16;
4368
if(USES_LIST(mb_type, 0)){
4369
s->mv_dir = MV_DIR_FORWARD;
4371
mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
4372
my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
4373
s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
4374
s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
4377
if(USES_LIST(mb_type, 1)){
4378
s->mv_dir |= MV_DIR_BACKWARD;
4380
mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
4381
my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
4382
s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
4383
s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
4385
}else if(!IS_DIRECT(mb_type)){
4386
s->mv_type= MV_TYPE_FIELD;
4388
if(USES_LIST(mb_type, 0)){
4389
s->mv_dir = MV_DIR_FORWARD;
4392
mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
4393
my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
4394
s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
4395
s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
4399
if(USES_LIST(mb_type, 1)){
4400
s->mv_dir |= MV_DIR_BACKWARD;
4403
mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
4404
my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
4405
s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
4406
s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
4412
if(IS_DIRECT(mb_type)){
4413
if(IS_SKIP(mb_type))
4416
mx = h263_decode_motion(s, 0, 1);
4417
my = h263_decode_motion(s, 0, 1);
4420
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4421
mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
4423
s->current_picture.mb_type[xy]= mb_type;
4424
} else { /* I-Frame */
4426
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
4428
av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
4436
s->ac_pred = get_bits1(&s->gb);
4438
s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
4440
s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
4442
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
4444
av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
4447
cbp = (cbpc & 3) | (cbpy << 2);
4449
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
4452
if(!s->progressive_sequence)
4453
s->interlaced_dct= get_bits1(&s->gb);
4455
s->dsp.clear_blocks(s->block[0]);
4456
/* decode each block */
4457
for (i = 0; i < 6; i++) {
4458
if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
4465
/* decode each block */
4466
for (i = 0; i < 6; i++) {
4467
if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
4473
/* per-MB end of slice check */
4474
if(s->codec_id==CODEC_ID_MPEG4){
4475
if(mpeg4_is_resync(s)){
4476
const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
4477
if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
4486
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
4488
int code, val, sign, shift, l;
4489
code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
4496
sign = get_bits1(&s->gb);
4500
val = (val - 1) << shift;
4501
val |= get_bits(&s->gb, shift);
4508
/* modulo decoding */
4509
if (!s->h263_long_vectors) {
4510
l = INT_BIT - 5 - f_code;
4513
/* horrible h263 long vector mode */
4514
if (pred < -31 && val < -63)
4516
if (pred > 32 && val > 63)
4523
/* Decodes RVLC of H.263+ UMV */
4524
static int h263p_decode_umotion(MpegEncContext * s, int pred)
4528
if (get_bits1(&s->gb)) /* Motion difference = 0 */
4531
code = 2 + get_bits1(&s->gb);
4533
while (get_bits1(&s->gb))
4536
code += get_bits1(&s->gb);
4541
code = (sign) ? (pred - code) : (pred + code);
4543
av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
4549
static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
4552
int code, level, i, j, last, run;
4553
RLTable *rl = &rl_inter;
4554
const uint8_t *scan_table;
4555
GetBitContext gb= s->gb;
4557
scan_table = s->intra_scantable.permutated;
4558
if (s->h263_aic && s->mb_intra) {
4562
if (s->h263_aic_dir)
4563
scan_table = s->intra_v_scantable.permutated; /* left */
4565
scan_table = s->intra_h_scantable.permutated; /* top */
4567
} else if (s->mb_intra) {
4569
if(s->codec_id == CODEC_ID_RV10){
4570
#ifdef CONFIG_RV10_DECODER
4571
if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
4572
int component, diff;
4573
component = (n <= 3 ? 0 : n - 4 + 1);
4574
level = s->last_dc[component];
4575
if (s->rv10_first_dc_coded[component]) {
4576
diff = rv_decode_dc(s, n);
4580
level = level & 0xff; /* handle wrap round */
4581
s->last_dc[component] = level;
4583
s->rv10_first_dc_coded[component] = 1;
4586
level = get_bits(&s->gb, 8);
4592
level = get_bits(&s->gb, 8);
4593
if((level&0x7F) == 0){
4594
av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
4595
if(s->error_resilience >= FF_ER_COMPLIANT)
4607
if (s->mb_intra && s->h263_aic)
4609
s->block_last_index[n] = i - 1;
4614
code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
4616
av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
4619
if (code == rl->n) {
4621
if (s->h263_flv > 1) {
4622
int is11 = get_bits1(&s->gb);
4623
last = get_bits1(&s->gb);
4624
run = get_bits(&s->gb, 6);
4626
level = get_sbits(&s->gb, 11);
4628
level = get_sbits(&s->gb, 7);
4631
last = get_bits1(&s->gb);
4632
run = get_bits(&s->gb, 6);
4633
level = (int8_t)get_bits(&s->gb, 8);
4635
if (s->codec_id == CODEC_ID_RV10) {
4636
/* XXX: should patch encoder too */
4637
level = get_sbits(&s->gb, 12);
4639
level = get_bits(&s->gb, 5);
4640
level |= get_sbits(&s->gb, 6)<<5;
4645
run = rl->table_run[code];
4646
level = rl->table_level[code];
4647
last = code >= rl->last;
4648
if (get_bits1(&s->gb))
4653
if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
4654
//looks like a hack but no, it's the way its supposed to work ...
4658
memset(block, 0, sizeof(DCTELEM)*64);
4661
av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
4671
if (s->mb_intra && s->h263_aic) {
4672
h263_pred_acdc(s, block, n);
4675
s->block_last_index[n] = i;
4680
* decodes the dc value.
4681
* @param n block index (0-3 are luma, 4-5 are chroma)
4682
* @param dir_ptr the prediction direction will be stored here
4683
* @return the quantized dc
4685
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
4690
code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
4692
code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
4693
if (code < 0 || code > 9 /* && s->nbit<9 */){
4694
av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
4702
level= 2*get_bits1(&s->gb)-1;
4704
if(get_bits1(&s->gb))
4705
level = get_bits(&s->gb, code-1) + (1<<(code-1));
4707
level = -get_bits(&s->gb, code-1) - (1<<(code-1));
4710
level = get_xbits(&s->gb, code);
4714
if(get_bits1(&s->gb)==0){ /* marker */
4715
if(s->error_resilience>=2){
4716
av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
4723
return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
4728
* @return <0 if an error occured
4730
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
4731
int n, int coded, int intra, int rvlc)
4733
int level, i, last, run;
4736
RL_VLC_ELEM * rl_vlc;
4737
const uint8_t * scan_table;
4740
//Note intra & rvlc should be optimized away if this is inlined
4743
if(s->qscale < s->intra_dc_threshold){
4745
if(s->partitioned_frame){
4746
level = s->dc_val[0][ s->block_index[n] ];
4747
if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
4748
else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
4749
dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
4751
level = mpeg4_decode_dc(s, n, &dc_pred_dir);
4764
rl = &rvlc_rl_intra;
4765
rl_vlc = rvlc_rl_intra.rl_vlc[0];
4768
rl_vlc = rl_intra.rl_vlc[0];
4771
if (dc_pred_dir == 0)
4772
scan_table = s->intra_v_scantable.permutated; /* left */
4774
scan_table = s->intra_h_scantable.permutated; /* top */
4776
scan_table = s->intra_scantable.permutated;
4783
s->block_last_index[n] = i;
4786
if(rvlc) rl = &rvlc_rl_inter;
4787
else rl = &rl_inter;
4789
scan_table = s->intra_scantable.permutated;
4795
rl_vlc = rvlc_rl_inter.rl_vlc[0];
4797
rl_vlc = rl_inter.rl_vlc[0];
4800
qmul = s->qscale << 1;
4801
qadd = (s->qscale - 1) | 1;
4803
rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
4805
rl_vlc = rl_inter.rl_vlc[s->qscale];
4810
OPEN_READER(re, &s->gb);
4812
UPDATE_CACHE(re, &s->gb);
4813
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
4817
if(SHOW_UBITS(re, &s->gb, 1)==0){
4818
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
4820
}; SKIP_CACHE(re, &s->gb, 1);
4822
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4823
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4824
SKIP_COUNTER(re, &s->gb, 1+1+6);
4825
UPDATE_CACHE(re, &s->gb);
4827
if(SHOW_UBITS(re, &s->gb, 1)==0){
4828
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
4830
}; SKIP_CACHE(re, &s->gb, 1);
4832
level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
4834
if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
4835
av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
4837
}; SKIP_CACHE(re, &s->gb, 5);
4839
level= level * qmul + qadd;
4840
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
4841
SKIP_COUNTER(re, &s->gb, 1+11+5+1);
4847
cache= GET_CACHE(re, &s->gb);
4850
cache ^= 0xC0000000;
4852
if (cache&0x80000000) {
4853
if (cache&0x40000000) {
4855
SKIP_CACHE(re, &s->gb, 2);
4856
last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
4857
run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
4858
SKIP_COUNTER(re, &s->gb, 2+1+6);
4859
UPDATE_CACHE(re, &s->gb);
4862
level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
4864
if(SHOW_UBITS(re, &s->gb, 1)==0){
4865
av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
4867
}; SKIP_CACHE(re, &s->gb, 1);
4869
level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
4871
if(SHOW_UBITS(re, &s->gb, 1)==0){
4872
av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
4874
}; LAST_SKIP_CACHE(re, &s->gb, 1);
4876
SKIP_COUNTER(re, &s->gb, 1+12+1);
4880
if(s->error_resilience >= FF_ER_COMPLIANT){
4881
const int abs_level= ABS(level);
4882
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
4883
const int run1= run - rl->max_run[last][abs_level] - 1;
4884
if(abs_level <= rl->max_level[last][run]){
4885
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
4888
if(s->error_resilience > FF_ER_COMPLIANT){
4889
if(abs_level <= rl->max_level[last][run]*2){
4890
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
4893
if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
4894
av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
4901
if (level>0) level= level * qmul + qadd;
4902
else level= level * qmul - qadd;
4904
if((unsigned)(level + 2048) > 4095){
4905
if(s->error_resilience > FF_ER_COMPLIANT){
4906
if(level > 2560 || level<-2560){
4907
av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
4911
level= level<0 ? -2048 : 2047;
4918
#if MIN_CACHE_BITS < 20
4919
LAST_SKIP_BITS(re, &s->gb, 2);
4920
UPDATE_CACHE(re, &s->gb);
4922
SKIP_BITS(re, &s->gb, 2);
4924
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4925
i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
4926
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4927
LAST_SKIP_BITS(re, &s->gb, 1);
4931
#if MIN_CACHE_BITS < 19
4932
LAST_SKIP_BITS(re, &s->gb, 1);
4933
UPDATE_CACHE(re, &s->gb);
4935
SKIP_BITS(re, &s->gb, 1);
4937
GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
4939
level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
4940
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4941
LAST_SKIP_BITS(re, &s->gb, 1);
4946
level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
4947
LAST_SKIP_BITS(re, &s->gb, 1);
4952
av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
4956
block[scan_table[i]] = level;
4960
block[scan_table[i]] = level;
4962
CLOSE_READER(re, &s->gb);
4966
if(s->qscale >= s->intra_dc_threshold){
4967
block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
4972
mpeg4_pred_ac(s, block, n, dc_pred_dir);
4974
i = 63; /* XXX: not optimal */
4977
s->block_last_index[n] = i;
4981
/* most is hardcoded. should extend to handle all h263 streams */
4982
int h263_decode_picture_header(MpegEncContext *s)
4984
int format, width, height, i;
4987
align_get_bits(&s->gb);
4989
startcode= get_bits(&s->gb, 22-8);
4991
for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
4992
startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
4994
if(startcode == 0x20)
4998
if (startcode != 0x20) {
4999
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
5002
/* temporal reference */
5003
i = get_bits(&s->gb, 8); /* picture timestamp */
5004
if( (s->picture_number&~0xFF)+i < s->picture_number)
5006
s->current_picture_ptr->pts=
5007
s->picture_number= (s->picture_number&~0xFF) + i;
5009
/* PTYPE starts here */
5010
if (get_bits1(&s->gb) != 1) {
5012
av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
5015
if (get_bits1(&s->gb) != 0) {
5016
av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
5017
return -1; /* h263 id */
5019
skip_bits1(&s->gb); /* split screen off */
5020
skip_bits1(&s->gb); /* camera off */
5021
skip_bits1(&s->gb); /* freeze picture release off */
5023
format = get_bits(&s->gb, 3);
5028
7 extended PTYPE (PLUSPTYPE)
5031
if (format != 7 && format != 6) {
5034
width = h263_format[format][0];
5035
height = h263_format[format][1];
5039
s->pict_type = I_TYPE + get_bits1(&s->gb);
5041
s->h263_long_vectors = get_bits1(&s->gb);
5043
if (get_bits1(&s->gb) != 0) {
5044
av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
5045
return -1; /* SAC: off */
5047
s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5048
s->unrestricted_mv = s->h263_long_vectors || s->obmc;
5050
if (get_bits1(&s->gb) != 0) {
5051
av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
5052
return -1; /* not PB frame */
5054
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
5055
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
5059
s->avctx->sample_aspect_ratio= (AVRational){12,11};
5060
s->avctx->time_base= (AVRational){1001, 30000};
5066
ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
5068
/* ufep other than 0 and 1 are reserved */
5071
format = get_bits(&s->gb, 3);
5072
dprintf("ufep=1, format: %d\n", format);
5073
s->custom_pcf= get_bits1(&s->gb);
5074
s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
5075
if (get_bits1(&s->gb) != 0) {
5076
av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
5078
s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
5079
s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
5080
s->loop_filter= get_bits1(&s->gb);
5081
s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
5083
s->h263_slice_structured= get_bits1(&s->gb);
5084
if (get_bits1(&s->gb) != 0) {
5085
av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
5087
if (get_bits1(&s->gb) != 0) {
5088
av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
5090
s->alt_inter_vlc= get_bits1(&s->gb);
5091
s->modified_quant= get_bits1(&s->gb);
5092
if(s->modified_quant)
5093
s->chroma_qscale_table= ff_h263_chroma_qscale_table;
5095
skip_bits(&s->gb, 1); /* Prevent start code emulation */
5097
skip_bits(&s->gb, 3); /* Reserved */
5098
} else if (ufep != 0) {
5099
av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
5104
s->pict_type = get_bits(&s->gb, 3);
5105
switch(s->pict_type){
5106
case 0: s->pict_type= I_TYPE;break;
5107
case 1: s->pict_type= P_TYPE;break;
5108
case 3: s->pict_type= B_TYPE;break;
5109
case 7: s->pict_type= I_TYPE;break; //ZYGO
5113
skip_bits(&s->gb, 2);
5114
s->no_rounding = get_bits1(&s->gb);
5115
skip_bits(&s->gb, 4);
5117
/* Get the picture dimensions */
5120
/* Custom Picture Format (CPFMT) */
5121
s->aspect_ratio_info = get_bits(&s->gb, 4);
5122
dprintf("aspect: %d\n", s->aspect_ratio_info);
5127
3 - 10:11 (525-type 4:3)
5128
4 - 16:11 (CIF 16:9)
5129
5 - 40:33 (525-type 16:9)
5132
width = (get_bits(&s->gb, 9) + 1) * 4;
5134
height = get_bits(&s->gb, 9) * 4;
5135
dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
5136
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
5137
/* aspected dimensions */
5138
s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
5139
s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
5141
s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5144
width = h263_format[format][0];
5145
height = h263_format[format][1];
5146
s->avctx->sample_aspect_ratio= (AVRational){12,11};
5148
if ((width == 0) || (height == 0))
5155
s->avctx->time_base.den= 1800000;
5156
s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
5157
s->avctx->time_base.num*= get_bits(&s->gb, 7);
5158
if(s->avctx->time_base.num == 0){
5159
av_log(s, AV_LOG_ERROR, "zero framerate\n");
5162
gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
5163
s->avctx->time_base.den /= gcd;
5164
s->avctx->time_base.num /= gcd;
5165
// av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num);
5167
s->avctx->time_base= (AVRational){1001, 30000};
5172
skip_bits(&s->gb, 2); //extended Temporal reference
5177
if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
5180
if(s->h263_slice_structured){
5181
if (get_bits1(&s->gb) != 0) {
5182
av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
5184
if (get_bits1(&s->gb) != 0) {
5185
av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
5190
s->qscale = get_bits(&s->gb, 5);
5193
s->mb_width = (s->width + 15) / 16;
5194
s->mb_height = (s->height + 15) / 16;
5195
s->mb_num = s->mb_width * s->mb_height;
5198
while (get_bits1(&s->gb) != 0) {
5199
skip_bits(&s->gb, 8);
5202
if(s->h263_slice_structured){
5203
if (get_bits1(&s->gb) != 1) {
5204
av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
5208
ff_h263_decode_mba(s);
5210
if (get_bits1(&s->gb) != 1) {
5211
av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
5218
s->y_dc_scale_table=
5219
s->c_dc_scale_table= ff_aic_dc_scale_table;
5221
s->y_dc_scale_table=
5222
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
5225
if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5226
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",
5227
s->qscale, av_get_pict_type_char(s->pict_type),
5228
s->gb.size_in_bits, 1-s->no_rounding,
5229
s->obmc ? " AP" : "",
5230
s->umvplus ? " UMV" : "",
5231
s->h263_long_vectors ? " LONG" : "",
5232
s->h263_plus ? " +" : "",
5233
s->h263_aic ? " AIC" : "",
5234
s->alt_inter_vlc ? " AIV" : "",
5235
s->modified_quant ? " MQ" : "",
5236
s->loop_filter ? " LOOP" : "",
5237
s->h263_slice_structured ? " SS" : "",
5238
s->avctx->time_base.den, s->avctx->time_base.num
5242
if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
5244
for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5245
av_log(s->avctx, AV_LOG_DEBUG, "\n");
5246
for(i=0; i<13; i++){
5248
int v= get_bits(&s->gb, 8);
5249
v |= get_sbits(&s->gb, 8)<<8;
5250
av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
5252
av_log(s->avctx, AV_LOG_DEBUG, "\n");
5254
for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
5261
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
5264
int a= 2<<s->sprite_warping_accuracy;
5265
int rho= 3-s->sprite_warping_accuracy;
5267
const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
5268
int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
5269
int sprite_ref[4][2];
5270
int virtual_ref[2][2];
5272
int alpha=0, beta=0;
5277
for(i=0; i<s->num_sprite_warping_points; i++){
5281
length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5283
x= get_xbits(gb, length);
5285
if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
5287
length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
5289
y=get_xbits(gb, length);
5291
skip_bits1(gb); /* marker bit */
5292
//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
5297
while((1<<alpha)<w) alpha++;
5298
while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
5302
// Note, the 4th point isn't used for GMC
5303
if(s->divx_version==500 && s->divx_build==413){
5304
sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
5305
sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
5306
sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
5307
sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
5308
sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
5309
sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
5311
sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
5312
sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
5313
sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
5314
sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
5315
sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
5316
sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
5318
/* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
5319
sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
5321
// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
5322
// perhaps it should be reordered to be more readable ...
5323
// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
5324
// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
5325
virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
5326
+ 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);
5327
virtual_ref[0][1]= 16*vop_ref[0][1]
5328
+ 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);
5329
virtual_ref[1][0]= 16*vop_ref[0][0]
5330
+ 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);
5331
virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
5332
+ 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);
5334
switch(s->num_sprite_warping_points)
5337
s->sprite_offset[0][0]= 0;
5338
s->sprite_offset[0][1]= 0;
5339
s->sprite_offset[1][0]= 0;
5340
s->sprite_offset[1][1]= 0;
5341
s->sprite_delta[0][0]= a;
5342
s->sprite_delta[0][1]= 0;
5343
s->sprite_delta[1][0]= 0;
5344
s->sprite_delta[1][1]= a;
5345
s->sprite_shift[0]= 0;
5346
s->sprite_shift[1]= 0;
5349
s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
5350
s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
5351
s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
5352
s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
5353
s->sprite_delta[0][0]= a;
5354
s->sprite_delta[0][1]= 0;
5355
s->sprite_delta[1][0]= 0;
5356
s->sprite_delta[1][1]= a;
5357
s->sprite_shift[0]= 0;
5358
s->sprite_shift[1]= 0;
5361
s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
5362
+ (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
5363
+ ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
5364
+ (1<<(alpha+rho-1));
5365
s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
5366
+ (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
5367
+ (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
5368
+ (1<<(alpha+rho-1));
5369
s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
5370
+( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
5371
+2*w2*r*sprite_ref[0][0]
5373
+ (1<<(alpha+rho+1)));
5374
s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
5375
+(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
5376
+2*w2*r*sprite_ref[0][1]
5378
+ (1<<(alpha+rho+1)));
5379
s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5380
s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
5381
s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
5382
s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
5384
s->sprite_shift[0]= alpha+rho;
5385
s->sprite_shift[1]= alpha+rho+2;
5388
min_ab= FFMIN(alpha, beta);
5391
s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
5392
+ (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
5393
+ (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
5394
+ (1<<(alpha+beta+rho-min_ab-1));
5395
s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
5396
+ (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
5397
+ (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
5398
+ (1<<(alpha+beta+rho-min_ab-1));
5399
s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
5400
+ (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
5401
+ 2*w2*h3*r*sprite_ref[0][0]
5403
+ (1<<(alpha+beta+rho-min_ab+1));
5404
s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
5405
+ (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
5406
+ 2*w2*h3*r*sprite_ref[0][1]
5408
+ (1<<(alpha+beta+rho-min_ab+1));
5409
s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
5410
s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
5411
s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
5412
s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
5414
s->sprite_shift[0]= alpha + beta + rho - min_ab;
5415
s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
5418
/* try to simplify the situation */
5419
if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
5420
&& s->sprite_delta[0][1] == 0
5421
&& s->sprite_delta[1][0] == 0
5422
&& s->sprite_delta[1][1] == a<<s->sprite_shift[0])
5424
s->sprite_offset[0][0]>>=s->sprite_shift[0];
5425
s->sprite_offset[0][1]>>=s->sprite_shift[0];
5426
s->sprite_offset[1][0]>>=s->sprite_shift[1];
5427
s->sprite_offset[1][1]>>=s->sprite_shift[1];
5428
s->sprite_delta[0][0]= a;
5429
s->sprite_delta[0][1]= 0;
5430
s->sprite_delta[1][0]= 0;
5431
s->sprite_delta[1][1]= a;
5432
s->sprite_shift[0]= 0;
5433
s->sprite_shift[1]= 0;
5434
s->real_sprite_warping_points=1;
5437
int shift_y= 16 - s->sprite_shift[0];
5438
int shift_c= 16 - s->sprite_shift[1];
5439
//printf("shifts %d %d\n", shift_y, shift_c);
5441
s->sprite_offset[0][i]<<= shift_y;
5442
s->sprite_offset[1][i]<<= shift_c;
5443
s->sprite_delta[0][i]<<= shift_y;
5444
s->sprite_delta[1][i]<<= shift_y;
5445
s->sprite_shift[i]= 16;
5447
s->real_sprite_warping_points= s->num_sprite_warping_points;
5450
printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
5451
vop_ref[0][0], vop_ref[0][1],
5452
vop_ref[1][0], vop_ref[1][1],
5453
vop_ref[2][0], vop_ref[2][1],
5454
sprite_ref[0][0], sprite_ref[0][1],
5455
sprite_ref[1][0], sprite_ref[1][1],
5456
sprite_ref[2][0], sprite_ref[2][1],
5457
virtual_ref[0][0], virtual_ref[0][1],
5458
virtual_ref[1][0], virtual_ref[1][1]
5461
printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
5462
s->sprite_offset[0][0], s->sprite_offset[0][1],
5463
s->sprite_delta[0][0], s->sprite_delta[0][1],
5464
s->sprite_delta[1][0], s->sprite_delta[1][1],
5470
static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
5471
int hours, minutes, seconds;
5473
hours= get_bits(gb, 5);
5474
minutes= get_bits(gb, 6);
5476
seconds= get_bits(gb, 6);
5478
s->time_base= seconds + 60*(minutes + 60*hours);
5486
static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
5487
int width, height, vo_ver_id;
5490
skip_bits(gb, 1); /* random access */
5491
s->vo_type= get_bits(gb, 8);
5492
if (get_bits1(gb) != 0) { /* is_ol_id */
5493
vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
5494
skip_bits(gb, 3); /* vo_priority */
5498
//printf("vo type:%d\n",s->vo_type);
5499
s->aspect_ratio_info= get_bits(gb, 4);
5500
if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
5501
s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
5502
s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
5504
s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
5507
if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
5508
int chroma_format= get_bits(gb, 2);
5509
if(chroma_format!=1){
5510
av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
5512
s->low_delay= get_bits1(gb);
5513
if(get_bits1(gb)){ /* vbv parameters */
5514
get_bits(gb, 15); /* first_half_bitrate */
5515
skip_bits1(gb); /* marker */
5516
get_bits(gb, 15); /* latter_half_bitrate */
5517
skip_bits1(gb); /* marker */
5518
get_bits(gb, 15); /* first_half_vbv_buffer_size */
5519
skip_bits1(gb); /* marker */
5520
get_bits(gb, 3); /* latter_half_vbv_buffer_size */
5521
get_bits(gb, 11); /* first_half_vbv_occupancy */
5522
skip_bits1(gb); /* marker */
5523
get_bits(gb, 15); /* latter_half_vbv_occupancy */
5524
skip_bits1(gb); /* marker */
5527
// set low delay flag only once the smartest? low delay detection won't be overriden
5528
if(s->picture_number==0)
5532
s->shape = get_bits(gb, 2); /* vol shape */
5533
if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
5534
if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
5535
av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
5536
skip_bits(gb, 4); //video_object_layer_shape_extension
5539
check_marker(gb, "before time_increment_resolution");
5541
s->avctx->time_base.den = get_bits(gb, 16);
5542
if(!s->avctx->time_base.den){
5543
av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
5547
s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
5548
if (s->time_increment_bits < 1)
5549
s->time_increment_bits = 1;
5551
check_marker(gb, "before fixed_vop_rate");
5553
if (get_bits1(gb) != 0) { /* fixed_vop_rate */
5554
s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
5556
s->avctx->time_base.num = 1;
5560
if (s->shape != BIN_ONLY_SHAPE) {
5561
if (s->shape == RECT_SHAPE) {
5562
skip_bits1(gb); /* marker */
5563
width = get_bits(gb, 13);
5564
skip_bits1(gb); /* marker */
5565
height = get_bits(gb, 13);
5566
skip_bits1(gb); /* marker */
5567
if(width && height && !(s->width && s->avctx->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */
5570
// printf("width/height: %d %d\n", width, height);
5574
s->progressive_sequence=
5575
s->progressive_frame= get_bits1(gb)^1;
5576
if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
5577
av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
5578
if (vo_ver_id == 1) {
5579
s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
5581
s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
5583
if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
5584
if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
5585
if(s->vol_sprite_usage==STATIC_SPRITE){
5586
s->sprite_width = get_bits(gb, 13);
5587
skip_bits1(gb); /* marker */
5588
s->sprite_height= get_bits(gb, 13);
5589
skip_bits1(gb); /* marker */
5590
s->sprite_left = get_bits(gb, 13);
5591
skip_bits1(gb); /* marker */
5592
s->sprite_top = get_bits(gb, 13);
5593
skip_bits1(gb); /* marker */
5595
s->num_sprite_warping_points= get_bits(gb, 6);
5596
s->sprite_warping_accuracy = get_bits(gb, 2);
5597
s->sprite_brightness_change= get_bits1(gb);
5598
if(s->vol_sprite_usage==STATIC_SPRITE)
5599
s->low_latency_sprite= get_bits1(gb);
5601
// FIXME sadct disable bit if verid!=1 && shape not rect
5603
if (get_bits1(gb) == 1) { /* not_8_bit */
5604
s->quant_precision = get_bits(gb, 4); /* quant_precision */
5605
if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
5606
if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
5608
s->quant_precision = 5;
5611
// FIXME a bunch of grayscale shape things
5613
if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
5616
/* load default matrixes */
5617
for(i=0; i<64; i++){
5618
int j= s->dsp.idct_permutation[i];
5619
v= ff_mpeg4_default_intra_matrix[i];
5620
s->intra_matrix[j]= v;
5621
s->chroma_intra_matrix[j]= v;
5623
v= ff_mpeg4_default_non_intra_matrix[i];
5624
s->inter_matrix[j]= v;
5625
s->chroma_inter_matrix[j]= v;
5628
/* load custom intra matrix */
5631
for(i=0; i<64; i++){
5637
j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5638
s->intra_matrix[j]= v;
5639
s->chroma_intra_matrix[j]= v;
5642
/* replicate last value */
5644
int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5645
s->intra_matrix[j]= last;
5646
s->chroma_intra_matrix[j]= last;
5650
/* load custom non intra matrix */
5653
for(i=0; i<64; i++){
5659
j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5660
s->inter_matrix[j]= v;
5661
s->chroma_inter_matrix[j]= v;
5664
/* replicate last value */
5666
int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
5667
s->inter_matrix[j]= last;
5668
s->chroma_inter_matrix[j]= last;
5672
// FIXME a bunch of grayscale shape things
5676
s->quarter_sample= get_bits1(gb);
5677
else s->quarter_sample=0;
5679
if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
5681
s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
5683
s->data_partitioning= get_bits1(gb);
5684
if(s->data_partitioning){
5685
s->rvlc= get_bits1(gb);
5688
if(vo_ver_id != 1) {
5689
s->new_pred= get_bits1(gb);
5691
av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
5692
skip_bits(gb, 2); /* requested upstream message type */
5693
skip_bits1(gb); /* newpred segment type */
5695
s->reduced_res_vop= get_bits1(gb);
5696
if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
5700
s->reduced_res_vop= 0;
5703
s->scalability= get_bits1(gb);
5705
if (s->scalability) {
5706
GetBitContext bak= *gb;
5708
int ref_layer_sampling_dir;
5709
int h_sampling_factor_n;
5710
int h_sampling_factor_m;
5711
int v_sampling_factor_n;
5712
int v_sampling_factor_m;
5714
s->hierachy_type= get_bits1(gb);
5715
ref_layer_id= get_bits(gb, 4);
5716
ref_layer_sampling_dir= get_bits1(gb);
5717
h_sampling_factor_n= get_bits(gb, 5);
5718
h_sampling_factor_m= get_bits(gb, 5);
5719
v_sampling_factor_n= get_bits(gb, 5);
5720
v_sampling_factor_m= get_bits(gb, 5);
5721
s->enhancement_type= get_bits1(gb);
5723
if( h_sampling_factor_n==0 || h_sampling_factor_m==0
5724
|| v_sampling_factor_n==0 || v_sampling_factor_m==0){
5726
// fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
5731
av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
5733
// bin shape stuff FIXME
5740
* decodes the user data stuff in the header.
5741
* allso inits divx/xvid/lavc_version/build
5743
static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
5747
int ver = 0, build = 0, ver2 = 0, ver3 = 0;
5750
for(i=0; i<255 && gb->index < gb->size_in_bits; i++){
5751
if(show_bits(gb, 23) == 0) break;
5752
buf[i]= get_bits(gb, 8);
5756
/* divx detection */
5757
e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
5759
e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
5761
s->divx_version= ver;
5762
s->divx_build= build;
5763
s->divx_packed= e==3 && last=='p';
5766
/* ffmpeg detection */
5767
e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
5769
e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
5771
e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
5773
build= (ver<<16) + (ver2<<8) + ver3;
5776
if(strcmp(buf, "ffmpeg")==0){
5777
s->lavc_build= 4600;
5781
s->lavc_build= build;
5784
/* xvid detection */
5785
e=sscanf(buf, "XviD%d", &build);
5787
s->xvid_build= build;
5790
//printf("User Data: %s\n", buf);
5794
static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
5795
int time_incr, time_increment;
5797
s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
5798
if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
5799
av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
5803
s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
5804
if(s->partitioned_frame)
5805
s->decode_mb= mpeg4_decode_partitioned_mb;
5807
s->decode_mb= ff_mpeg4_decode_mb;
5810
while (get_bits1(gb) != 0)
5813
check_marker(gb, "before time_increment");
5815
if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
5816
av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
5818
for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
5819
if(show_bits(gb, s->time_increment_bits+1)&1) break;
5822
av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
5825
if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
5826
else time_increment= get_bits(gb, s->time_increment_bits);
5828
// printf("%d %X\n", s->time_increment_bits, time_increment);
5829
//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);
5830
if(s->pict_type!=B_TYPE){
5831
s->last_time_base= s->time_base;
5832
s->time_base+= time_incr;
5833
s->time= s->time_base*s->avctx->time_base.den + time_increment;
5834
if(s->workaround_bugs&FF_BUG_UMP4){
5835
if(s->time < s->last_non_b_time){
5836
// fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
5838
s->time+= s->avctx->time_base.den;
5841
s->pp_time= s->time - s->last_non_b_time;
5842
s->last_non_b_time= s->time;
5844
s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
5845
s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
5846
if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
5847
// printf("messed up order, maybe after seeking? skipping current b frame\n");
5848
return FRAME_SKIPPED;
5851
if(s->t_frame==0) s->t_frame= s->pb_time;
5852
if(s->t_frame==0) s->t_frame=1; // 1/0 protection
5853
s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
5854
- ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5855
s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
5856
- ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
5858
//av_log(s->avctx, AV_LOG_DEBUG, "last nonb %Ld last_base %d time %Ld 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);
5860
if(s->avctx->time_base.num)
5861
s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
5863
s->current_picture_ptr->pts= AV_NOPTS_VALUE;
5864
if(s->avctx->debug&FF_DEBUG_PTS)
5865
av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
5867
check_marker(gb, "before vop_coded");
5870
if (get_bits1(gb) != 1){
5871
if(s->avctx->debug&FF_DEBUG_PICT_INFO)
5872
av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
5873
return FRAME_SKIPPED;
5875
//printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base,
5876
//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
5877
if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
5878
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
5879
/* rounding type for motion estimation */
5880
s->no_rounding = get_bits1(gb);
5884
//FIXME reduced res stuff
5886
if (s->shape != RECT_SHAPE) {
5887
if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
5888
int width, height, hor_spat_ref, ver_spat_ref;
5890
width = get_bits(gb, 13);
5891
skip_bits1(gb); /* marker */
5892
height = get_bits(gb, 13);
5893
skip_bits1(gb); /* marker */
5894
hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
5895
skip_bits1(gb); /* marker */
5896
ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
5898
skip_bits1(gb); /* change_CR_disable */
5900
if (get_bits1(gb) != 0) {
5901
skip_bits(gb, 8); /* constant_alpha_value */
5904
//FIXME complexity estimation stuff
5906
if (s->shape != BIN_ONLY_SHAPE) {
5907
s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
5908
if(!s->progressive_sequence){
5909
s->top_field_first= get_bits1(gb);
5910
s->alternate_scan= get_bits1(gb);
5912
s->alternate_scan= 0;
5915
if(s->alternate_scan){
5916
ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
5917
ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
5918
ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
5919
ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5921
ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
5922
ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
5923
ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
5924
ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
5927
if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
5928
mpeg4_decode_sprite_trajectory(s, gb);
5929
if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
5930
if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
5933
if (s->shape != BIN_ONLY_SHAPE) {
5934
s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
5936
av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
5937
return -1; // makes no sense to continue, as there is nothing left from the image then
5940
if (s->pict_type != I_TYPE) {
5941
s->f_code = get_bits(gb, 3); /* fcode_for */
5943
av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
5944
return -1; // makes no sense to continue, as the MV decoding will break very quickly
5949
if (s->pict_type == B_TYPE) {
5950
s->b_code = get_bits(gb, 3);
5954
if(s->avctx->debug&FF_DEBUG_PICT_INFO){
5955
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",
5956
s->qscale, s->f_code, s->b_code,
5957
s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
5958
gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
5959
s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
5960
s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
5963
if(!s->scalability){
5964
if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
5965
skip_bits1(gb); // vop shape coding type
5968
if(s->enhancement_type){
5969
int load_backward_shape= get_bits1(gb);
5970
if(load_backward_shape){
5971
av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
5974
skip_bits(gb, 2); //ref_select_code
5977
/* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
5978
// note we cannot detect divx5 without b-frames easily (although it's buggy too)
5979
if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
5980
av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
5984
s->picture_number++; // better than pic number==0 always ;)
5986
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
5987
s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
5989
if(s->workaround_bugs&FF_BUG_EDGE){
5990
s->h_edge_pos= s->width;
5991
s->v_edge_pos= s->height;
5997
* decode mpeg4 headers
5998
* @return <0 if no VOP found (or a damaged one)
5999
* FRAME_SKIPPED if a not coded VOP is found
6000
* 0 if a VOP is found
6002
int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
6006
/* search next start code */
6009
if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
6011
if(get_bits(gb, 8) == 0xF0)
6012
return decode_vop_header(s, gb);
6017
if(get_bits_count(gb) >= gb->size_in_bits){
6018
if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
6019
av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
6020
return FRAME_SKIPPED; //divx bug
6022
return -1; //end of stream
6025
/* use the bits after the test */
6026
v = get_bits(gb, 8);
6027
startcode = ((startcode << 8) | v) & 0xffffffff;
6029
if((startcode&0xFFFFFF00) != 0x100)
6030
continue; //no startcode
6032
if(s->avctx->debug&FF_DEBUG_STARTCODE){
6033
av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
6034
if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
6035
else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
6036
else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6037
else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
6038
else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
6039
else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
6040
else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
6041
else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
6042
else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
6043
else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
6044
else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
6045
else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
6046
else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
6047
else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
6048
else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
6049
else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
6050
else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
6051
else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
6052
else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
6053
else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
6054
else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
6055
else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
6056
else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
6057
else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
6058
else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
6059
else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
6060
else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
6061
av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
6064
if(startcode >= 0x120 && startcode <= 0x12F){
6065
if(decode_vol_header(s, gb) < 0)
6068
else if(startcode == USER_DATA_STARTCODE){
6069
decode_user_data(s, gb);
6071
else if(startcode == GOP_STARTCODE){
6072
mpeg4_decode_gop_header(s, gb);
6074
else if(startcode == VOP_STARTCODE){
6075
return decode_vop_header(s, gb);
6083
/* don't understand why they choose a different header ! */
6084
int intel_h263_decode_picture_header(MpegEncContext *s)
6088
/* picture header */
6089
if (get_bits_long(&s->gb, 22) != 0x20) {
6090
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6093
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6095
if (get_bits1(&s->gb) != 1) {
6096
av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
6097
return -1; /* marker */
6099
if (get_bits1(&s->gb) != 0) {
6100
av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
6101
return -1; /* h263 id */
6103
skip_bits1(&s->gb); /* split screen off */
6104
skip_bits1(&s->gb); /* camera off */
6105
skip_bits1(&s->gb); /* freeze picture release off */
6107
format = get_bits(&s->gb, 3);
6109
av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
6114
s->pict_type = I_TYPE + get_bits1(&s->gb);
6116
s->unrestricted_mv = get_bits1(&s->gb);
6117
s->h263_long_vectors = s->unrestricted_mv;
6119
if (get_bits1(&s->gb) != 0) {
6120
av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
6121
return -1; /* SAC: off */
6123
if (get_bits1(&s->gb) != 0) {
6125
av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
6126
// return -1; /* advanced prediction mode: off */
6128
if (get_bits1(&s->gb) != 0) {
6129
av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
6130
return -1; /* PB frame mode */
6133
/* skip unknown header garbage */
6134
skip_bits(&s->gb, 41);
6136
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6137
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
6140
while (get_bits1(&s->gb) != 0) {
6141
skip_bits(&s->gb, 8);
6145
s->y_dc_scale_table=
6146
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
6151
int flv_h263_decode_picture_header(MpegEncContext *s)
6153
int format, width, height;
6155
/* picture header */
6156
if (get_bits_long(&s->gb, 17) != 1) {
6157
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
6160
format = get_bits(&s->gb, 5);
6161
if (format != 0 && format != 1) {
6162
av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
6165
s->h263_flv = format+1;
6166
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
6167
format = get_bits(&s->gb, 3);
6170
width = get_bits(&s->gb, 8);
6171
height = get_bits(&s->gb, 8);
6174
width = get_bits(&s->gb, 16);
6175
height = get_bits(&s->gb, 16);
6201
if(avcodec_check_dimensions(s->avctx, width, height))
6206
s->pict_type = I_TYPE + get_bits(&s->gb, 2);
6207
s->dropable= s->pict_type > P_TYPE;
6209
s->pict_type = P_TYPE;
6211
skip_bits1(&s->gb); /* deblocking flag */
6212
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
6216
s->unrestricted_mv = 1;
6217
s->h263_long_vectors = 0;
6220
while (get_bits1(&s->gb) != 0) {
6221
skip_bits(&s->gb, 8);
6225
if(s->avctx->debug & FF_DEBUG_PICT_INFO){
6226
av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
6227
s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
6230
s->y_dc_scale_table=
6231
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
added
removed
libavcodec/h263.c
