ffmpeg / libavcodec / h263.c @ f66e4f5f
History | View | Annotate | Download (212 KB)
| 1 |
/*
|
|---|---|
| 2 |
* H263/MPEG4 backend for ffmpeg encoder and decoder
|
| 3 |
* Copyright (c) 2000,2001 Fabrice Bellard.
|
| 4 |
* H263+ support.
|
| 5 |
* Copyright (c) 2001 Juan J. Sierralta P.
|
| 6 |
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
|
| 7 |
*
|
| 8 |
* This file is part of FFmpeg.
|
| 9 |
*
|
| 10 |
* FFmpeg is free software; you can redistribute it and/or
|
| 11 |
* modify it under the terms of the GNU Lesser General Public
|
| 12 |
* License as published by the Free Software Foundation; either
|
| 13 |
* version 2.1 of the License, or (at your option) any later version.
|
| 14 |
*
|
| 15 |
* FFmpeg is distributed in the hope that it will be useful,
|
| 16 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
| 17 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
| 18 |
* Lesser General Public License for more details.
|
| 19 |
*
|
| 20 |
* You should have received a copy of the GNU Lesser General Public
|
| 21 |
* License along with FFmpeg; if not, write to the Free Software
|
| 22 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
| 23 |
*
|
| 24 |
* ac prediction encoding, b-frame support, error resilience, optimizations,
|
| 25 |
* qpel decoding, gmc decoding, interlaced decoding,
|
| 26 |
* by Michael Niedermayer <michaelni@gmx.at>
|
| 27 |
*/
|
| 28 |
|
| 29 |
/**
|
| 30 |
* @file h263.c
|
| 31 |
* h263/mpeg4 codec.
|
| 32 |
*/
|
| 33 |
|
| 34 |
//#define DEBUG
|
| 35 |
#include <limits.h> |
| 36 |
|
| 37 |
#include "common.h" |
| 38 |
#include "dsputil.h" |
| 39 |
#include "avcodec.h" |
| 40 |
#include "mpegvideo.h" |
| 41 |
#include "h263data.h" |
| 42 |
#include "mpeg4data.h" |
| 43 |
|
| 44 |
//#undef NDEBUG
|
| 45 |
//#include <assert.h>
|
| 46 |
|
| 47 |
#define INTRA_MCBPC_VLC_BITS 6 |
| 48 |
#define INTER_MCBPC_VLC_BITS 7 |
| 49 |
#define CBPY_VLC_BITS 6 |
| 50 |
#define MV_VLC_BITS 9 |
| 51 |
#define DC_VLC_BITS 9 |
| 52 |
#define SPRITE_TRAJ_VLC_BITS 6 |
| 53 |
#define MB_TYPE_B_VLC_BITS 4 |
| 54 |
#define TEX_VLC_BITS 9 |
| 55 |
#define H263_MBTYPE_B_VLC_BITS 6 |
| 56 |
#define CBPC_B_VLC_BITS 3 |
| 57 |
|
| 58 |
#ifdef CONFIG_ENCODERS
|
| 59 |
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, |
| 60 |
int n);
|
| 61 |
static void h263p_encode_umotion(MpegEncContext * s, int val); |
| 62 |
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
| 63 |
int n, int dc, uint8_t *scan_table, |
| 64 |
PutBitContext *dc_pb, PutBitContext *ac_pb); |
| 65 |
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
| 66 |
uint8_t *scan_table); |
| 67 |
#endif
|
| 68 |
|
| 69 |
static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
| 70 |
static int h263p_decode_umotion(MpegEncContext * s, int pred); |
| 71 |
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
| 72 |
int n, int coded); |
| 73 |
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
| 74 |
static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, |
| 75 |
int n, int coded, int intra, int rvlc); |
| 76 |
#ifdef CONFIG_ENCODERS
|
| 77 |
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr); |
| 78 |
static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
| 79 |
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); |
| 80 |
#endif //CONFIG_ENCODERS |
| 81 |
static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); |
| 82 |
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding); |
| 83 |
|
| 84 |
#ifdef CONFIG_ENCODERS
|
| 85 |
static uint8_t uni_DCtab_lum_len[512]; |
| 86 |
static uint8_t uni_DCtab_chrom_len[512]; |
| 87 |
static uint16_t uni_DCtab_lum_bits[512]; |
| 88 |
static uint16_t uni_DCtab_chrom_bits[512]; |
| 89 |
|
| 90 |
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL; |
| 91 |
static uint8_t fcode_tab[MAX_MV*2+1]; |
| 92 |
static uint8_t umv_fcode_tab[MAX_MV*2+1]; |
| 93 |
|
| 94 |
static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
| 95 |
static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; |
| 96 |
static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; |
| 97 |
static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; |
| 98 |
static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; |
| 99 |
static uint8_t uni_h263_inter_rl_len [64*64*2*2]; |
| 100 |
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
|
| 101 |
//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
|
| 102 |
#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) |
| 103 |
|
| 104 |
/* mpeg4
|
| 105 |
inter
|
| 106 |
max level: 24/6
|
| 107 |
max run: 53/63
|
| 108 |
|
| 109 |
intra
|
| 110 |
max level: 53/16
|
| 111 |
max run: 29/41
|
| 112 |
*/
|
| 113 |
#endif
|
| 114 |
|
| 115 |
#if 0 //3IV1 is quite rare and it slows things down a tiny bit
|
| 116 |
#define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
|
| 117 |
#else
|
| 118 |
#define IS_3IV1 0 |
| 119 |
#endif
|
| 120 |
|
| 121 |
int h263_get_picture_format(int width, int height) |
| 122 |
{
|
| 123 |
int format;
|
| 124 |
|
| 125 |
if (width == 128 && height == 96) |
| 126 |
format = 1;
|
| 127 |
else if (width == 176 && height == 144) |
| 128 |
format = 2;
|
| 129 |
else if (width == 352 && height == 288) |
| 130 |
format = 3;
|
| 131 |
else if (width == 704 && height == 576) |
| 132 |
format = 4;
|
| 133 |
else if (width == 1408 && height == 1152) |
| 134 |
format = 5;
|
| 135 |
else
|
| 136 |
format = 7;
|
| 137 |
return format;
|
| 138 |
} |
| 139 |
|
| 140 |
#ifdef CONFIG_ENCODERS
|
| 141 |
|
| 142 |
static void aspect_to_info(MpegEncContext * s, AVRational aspect){ |
| 143 |
int i;
|
| 144 |
|
| 145 |
if(aspect.num==0) aspect= (AVRational){1,1}; |
| 146 |
|
| 147 |
for(i=1; i<6; i++){ |
| 148 |
if(av_cmp_q(pixel_aspect[i], aspect) == 0){ |
| 149 |
s->aspect_ratio_info=i; |
| 150 |
return;
|
| 151 |
} |
| 152 |
} |
| 153 |
|
| 154 |
s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
| 155 |
} |
| 156 |
|
| 157 |
void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
| 158 |
{
|
| 159 |
int format;
|
| 160 |
|
| 161 |
align_put_bits(&s->pb); |
| 162 |
|
| 163 |
put_bits(&s->pb, 17, 1); |
| 164 |
put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ |
| 165 |
put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp |
| 166 |
s->avctx->time_base.den) & 0xff); /* TemporalReference */ |
| 167 |
if (s->width == 352 && s->height == 288) |
| 168 |
format = 2;
|
| 169 |
else if (s->width == 176 && s->height == 144) |
| 170 |
format = 3;
|
| 171 |
else if (s->width == 128 && s->height == 96) |
| 172 |
format = 4;
|
| 173 |
else if (s->width == 320 && s->height == 240) |
| 174 |
format = 5;
|
| 175 |
else if (s->width == 160 && s->height == 120) |
| 176 |
format = 6;
|
| 177 |
else if (s->width <= 255 && s->height <= 255) |
| 178 |
format = 0; /* use 1 byte width & height */ |
| 179 |
else
|
| 180 |
format = 1; /* use 2 bytes width & height */ |
| 181 |
put_bits(&s->pb, 3, format); /* PictureSize */ |
| 182 |
if (format == 0) { |
| 183 |
put_bits(&s->pb, 8, s->width);
|
| 184 |
put_bits(&s->pb, 8, s->height);
|
| 185 |
} else if (format == 1) { |
| 186 |
put_bits(&s->pb, 16, s->width);
|
| 187 |
put_bits(&s->pb, 16, s->height);
|
| 188 |
} |
| 189 |
put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */ |
| 190 |
put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */ |
| 191 |
put_bits(&s->pb, 5, s->qscale); /* Quantizer */ |
| 192 |
put_bits(&s->pb, 1, 0); /* ExtraInformation */ |
| 193 |
|
| 194 |
if(s->h263_aic){
|
| 195 |
s->y_dc_scale_table= |
| 196 |
s->c_dc_scale_table= ff_aic_dc_scale_table; |
| 197 |
}else{
|
| 198 |
s->y_dc_scale_table= |
| 199 |
s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
| 200 |
} |
| 201 |
} |
| 202 |
|
| 203 |
void h263_encode_picture_header(MpegEncContext * s, int picture_number) |
| 204 |
{
|
| 205 |
int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
|
| 206 |
int best_clock_code=1; |
| 207 |
int best_divisor=60; |
| 208 |
int best_error= INT_MAX;
|
| 209 |
|
| 210 |
if(s->h263_plus){
|
| 211 |
for(i=0; i<2; i++){ |
| 212 |
int div, error;
|
| 213 |
div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den); |
| 214 |
div= av_clip(1, div, 127); |
| 215 |
error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div); |
| 216 |
if(error < best_error){
|
| 217 |
best_error= error; |
| 218 |
best_divisor= div; |
| 219 |
best_clock_code= i; |
| 220 |
} |
| 221 |
} |
| 222 |
} |
| 223 |
s->custom_pcf= best_clock_code!=1 || best_divisor!=60; |
| 224 |
coded_frame_rate= 1800000;
|
| 225 |
coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
|
| 226 |
|
| 227 |
align_put_bits(&s->pb); |
| 228 |
|
| 229 |
/* Update the pointer to last GOB */
|
| 230 |
s->ptr_lastgob = pbBufPtr(&s->pb); |
| 231 |
put_bits(&s->pb, 22, 0x20); /* PSC */ |
| 232 |
temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
|
| 233 |
(coded_frame_rate_base * (int64_t)s->avctx->time_base.den); |
| 234 |
put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */ |
| 235 |
|
| 236 |
put_bits(&s->pb, 1, 1); /* marker */ |
| 237 |
put_bits(&s->pb, 1, 0); /* h263 id */ |
| 238 |
put_bits(&s->pb, 1, 0); /* split screen off */ |
| 239 |
put_bits(&s->pb, 1, 0); /* camera off */ |
| 240 |
put_bits(&s->pb, 1, 0); /* freeze picture release off */ |
| 241 |
|
| 242 |
format = h263_get_picture_format(s->width, s->height); |
| 243 |
if (!s->h263_plus) {
|
| 244 |
/* H.263v1 */
|
| 245 |
put_bits(&s->pb, 3, format);
|
| 246 |
put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
|
| 247 |
/* By now UMV IS DISABLED ON H.263v1, since the restrictions
|
| 248 |
of H.263v1 UMV implies to check the predicted MV after
|
| 249 |
calculation of the current MB to see if we're on the limits */
|
| 250 |
put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ |
| 251 |
put_bits(&s->pb, 1, 0); /* SAC: off */ |
| 252 |
put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ |
| 253 |
put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ |
| 254 |
put_bits(&s->pb, 5, s->qscale);
|
| 255 |
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
| 256 |
} else {
|
| 257 |
int ufep=1; |
| 258 |
/* H.263v2 */
|
| 259 |
/* H.263 Plus PTYPE */
|
| 260 |
|
| 261 |
put_bits(&s->pb, 3, 7); |
| 262 |
put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */ |
| 263 |
if (format == 7) |
| 264 |
put_bits(&s->pb,3,6); /* Custom Source Format */ |
| 265 |
else
|
| 266 |
put_bits(&s->pb, 3, format);
|
| 267 |
|
| 268 |
put_bits(&s->pb,1, s->custom_pcf);
|
| 269 |
put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ |
| 270 |
put_bits(&s->pb,1,0); /* SAC: off */ |
| 271 |
put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */ |
| 272 |
put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
| 273 |
put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ |
| 274 |
put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ |
| 275 |
put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ |
| 276 |
put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ |
| 277 |
put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ |
| 278 |
put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ |
| 279 |
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
| 280 |
put_bits(&s->pb,3,0); /* Reserved */ |
| 281 |
|
| 282 |
put_bits(&s->pb, 3, s->pict_type == P_TYPE);
|
| 283 |
|
| 284 |
put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ |
| 285 |
put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */ |
| 286 |
put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
| 287 |
put_bits(&s->pb,2,0); /* Reserved */ |
| 288 |
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
| 289 |
|
| 290 |
/* This should be here if PLUSPTYPE */
|
| 291 |
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
| 292 |
|
| 293 |
if (format == 7) { |
| 294 |
/* Custom Picture Format (CPFMT) */
|
| 295 |
aspect_to_info(s, s->avctx->sample_aspect_ratio); |
| 296 |
|
| 297 |
put_bits(&s->pb,4,s->aspect_ratio_info);
|
| 298 |
put_bits(&s->pb,9,(s->width >> 2) - 1); |
| 299 |
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
| 300 |
put_bits(&s->pb,9,(s->height >> 2)); |
| 301 |
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
|
| 302 |
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
|
| 303 |
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
|
| 304 |
} |
| 305 |
} |
| 306 |
if(s->custom_pcf){
|
| 307 |
if(ufep){
|
| 308 |
put_bits(&s->pb, 1, best_clock_code);
|
| 309 |
put_bits(&s->pb, 7, best_divisor);
|
| 310 |
} |
| 311 |
put_bits(&s->pb, 2, (temp_ref>>8)&3); |
| 312 |
} |
| 313 |
|
| 314 |
/* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
|
| 315 |
if (s->umvplus)
|
| 316 |
// put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
|
| 317 |
//FIXME check actual requested range
|
| 318 |
put_bits(&s->pb,2,1); /* unlimited */ |
| 319 |
if(s->h263_slice_structured)
|
| 320 |
put_bits(&s->pb,2,0); /* no weird submodes */ |
| 321 |
|
| 322 |
put_bits(&s->pb, 5, s->qscale);
|
| 323 |
} |
| 324 |
|
| 325 |
put_bits(&s->pb, 1, 0); /* no PEI */ |
| 326 |
|
| 327 |
if(s->h263_slice_structured){
|
| 328 |
put_bits(&s->pb, 1, 1); |
| 329 |
|
| 330 |
assert(s->mb_x == 0 && s->mb_y == 0); |
| 331 |
ff_h263_encode_mba(s); |
| 332 |
|
| 333 |
put_bits(&s->pb, 1, 1); |
| 334 |
} |
| 335 |
|
| 336 |
if(s->h263_aic){
|
| 337 |
s->y_dc_scale_table= |
| 338 |
s->c_dc_scale_table= ff_aic_dc_scale_table; |
| 339 |
}else{
|
| 340 |
s->y_dc_scale_table= |
| 341 |
s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
| 342 |
} |
| 343 |
} |
| 344 |
|
| 345 |
/**
|
| 346 |
* Encodes a group of blocks header.
|
| 347 |
*/
|
| 348 |
void h263_encode_gob_header(MpegEncContext * s, int mb_line) |
| 349 |
{
|
| 350 |
put_bits(&s->pb, 17, 1); /* GBSC */ |
| 351 |
|
| 352 |
if(s->h263_slice_structured){
|
| 353 |
put_bits(&s->pb, 1, 1); |
| 354 |
|
| 355 |
ff_h263_encode_mba(s); |
| 356 |
|
| 357 |
if(s->mb_num > 1583) |
| 358 |
put_bits(&s->pb, 1, 1); |
| 359 |
put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
| 360 |
put_bits(&s->pb, 1, 1); |
| 361 |
put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ |
| 362 |
}else{
|
| 363 |
int gob_number= mb_line / s->gob_index;
|
| 364 |
|
| 365 |
put_bits(&s->pb, 5, gob_number); /* GN */ |
| 366 |
put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ |
| 367 |
put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
| 368 |
} |
| 369 |
} |
| 370 |
|
| 371 |
static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ |
| 372 |
int last=0; |
| 373 |
int j;
|
| 374 |
int rate=0; |
| 375 |
|
| 376 |
for(j=1; j<=block_last_index; j++){ |
| 377 |
const int index= scantable[j]; |
| 378 |
int level= block[index];
|
| 379 |
if(level){
|
| 380 |
level+= 64;
|
| 381 |
if((level&(~127)) == 0){ |
| 382 |
if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; |
| 383 |
else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; |
| 384 |
}else
|
| 385 |
rate += s->ac_esc_length; |
| 386 |
level-= 64;
|
| 387 |
|
| 388 |
last= j; |
| 389 |
} |
| 390 |
} |
| 391 |
|
| 392 |
return rate;
|
| 393 |
} |
| 394 |
|
| 395 |
static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) |
| 396 |
{
|
| 397 |
int score= 0; |
| 398 |
int i, n;
|
| 399 |
int8_t * const qscale_table= s->current_picture.qscale_table;
|
| 400 |
|
| 401 |
memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); |
| 402 |
|
| 403 |
for(n=0; n<6; n++){ |
| 404 |
int16_t *ac_val, *ac_val1; |
| 405 |
|
| 406 |
score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated); |
| 407 |
|
| 408 |
ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
| 409 |
ac_val1= ac_val; |
| 410 |
if(dir[n]){
|
| 411 |
const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
| 412 |
/* top prediction */
|
| 413 |
ac_val-= s->block_wrap[n]*16;
|
| 414 |
if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
| 415 |
/* same qscale */
|
| 416 |
for(i=1; i<8; i++){ |
| 417 |
const int level= block[n][s->dsp.idct_permutation[i ]]; |
| 418 |
block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
|
| 419 |
ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
|
| 420 |
ac_val1[i+8]= level;
|
| 421 |
} |
| 422 |
}else{
|
| 423 |
/* different qscale, we must rescale */
|
| 424 |
for(i=1; i<8; i++){ |
| 425 |
const int level= block[n][s->dsp.idct_permutation[i ]]; |
| 426 |
block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
|
| 427 |
ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
|
| 428 |
ac_val1[i+8]= level;
|
| 429 |
} |
| 430 |
} |
| 431 |
st[n]= s->intra_h_scantable.permutated; |
| 432 |
}else{
|
| 433 |
const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
| 434 |
/* left prediction */
|
| 435 |
ac_val-= 16;
|
| 436 |
if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
| 437 |
/* same qscale */
|
| 438 |
for(i=1; i<8; i++){ |
| 439 |
const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
| 440 |
block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
|
| 441 |
ac_val1[i ]= level; |
| 442 |
ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
|
| 443 |
} |
| 444 |
}else{
|
| 445 |
/* different qscale, we must rescale */
|
| 446 |
for(i=1; i<8; i++){ |
| 447 |
const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
| 448 |
block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
|
| 449 |
ac_val1[i ]= level; |
| 450 |
ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
|
| 451 |
} |
| 452 |
} |
| 453 |
st[n]= s->intra_v_scantable.permutated; |
| 454 |
} |
| 455 |
|
| 456 |
for(i=63; i>0; i--) //FIXME optimize |
| 457 |
if(block[n][ st[n][i] ]) break; |
| 458 |
s->block_last_index[n]= i; |
| 459 |
|
| 460 |
score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); |
| 461 |
} |
| 462 |
|
| 463 |
return score < 0; |
| 464 |
} |
| 465 |
|
| 466 |
static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) |
| 467 |
{
|
| 468 |
int i, n;
|
| 469 |
memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); |
| 470 |
|
| 471 |
for(n=0; n<6; n++){ |
| 472 |
int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
| 473 |
|
| 474 |
st[n]= s->intra_scantable.permutated; |
| 475 |
if(dir[n]){
|
| 476 |
/* top prediction */
|
| 477 |
for(i=1; i<8; i++){ |
| 478 |
block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
|
| 479 |
} |
| 480 |
}else{
|
| 481 |
/* left prediction */
|
| 482 |
for(i=1; i<8; i++){ |
| 483 |
block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
|
| 484 |
} |
| 485 |
} |
| 486 |
} |
| 487 |
} |
| 488 |
|
| 489 |
/**
|
| 490 |
* init s->current_picture.qscale_table from s->lambda_table
|
| 491 |
*/
|
| 492 |
static void ff_init_qscale_tab(MpegEncContext *s){ |
| 493 |
int8_t * const qscale_table= s->current_picture.qscale_table;
|
| 494 |
int i;
|
| 495 |
|
| 496 |
for(i=0; i<s->mb_num; i++){ |
| 497 |
unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ]; |
| 498 |
int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); |
| 499 |
qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax); |
| 500 |
} |
| 501 |
} |
| 502 |
|
| 503 |
/**
|
| 504 |
* modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
|
| 505 |
*/
|
| 506 |
void ff_clean_h263_qscales(MpegEncContext *s){
|
| 507 |
int i;
|
| 508 |
int8_t * const qscale_table= s->current_picture.qscale_table;
|
| 509 |
|
| 510 |
ff_init_qscale_tab(s); |
| 511 |
|
| 512 |
for(i=1; i<s->mb_num; i++){ |
| 513 |
if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2) |
| 514 |
qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2; |
| 515 |
} |
| 516 |
for(i=s->mb_num-2; i>=0; i--){ |
| 517 |
if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2) |
| 518 |
qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2; |
| 519 |
} |
| 520 |
|
| 521 |
if(s->codec_id != CODEC_ID_H263P){
|
| 522 |
for(i=1; i<s->mb_num; i++){ |
| 523 |
int mb_xy= s->mb_index2xy[i];
|
| 524 |
|
| 525 |
if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ |
| 526 |
s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER; |
| 527 |
} |
| 528 |
} |
| 529 |
} |
| 530 |
} |
| 531 |
|
| 532 |
/**
|
| 533 |
* modify mb_type & qscale so that encoding is acually possible in mpeg4
|
| 534 |
*/
|
| 535 |
void ff_clean_mpeg4_qscales(MpegEncContext *s){
|
| 536 |
int i;
|
| 537 |
int8_t * const qscale_table= s->current_picture.qscale_table;
|
| 538 |
|
| 539 |
ff_clean_h263_qscales(s); |
| 540 |
|
| 541 |
if(s->pict_type== B_TYPE){
|
| 542 |
int odd=0; |
| 543 |
/* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */
|
| 544 |
|
| 545 |
for(i=0; i<s->mb_num; i++){ |
| 546 |
int mb_xy= s->mb_index2xy[i];
|
| 547 |
odd += qscale_table[mb_xy]&1;
|
| 548 |
} |
| 549 |
|
| 550 |
if(2*odd > s->mb_num) odd=1; |
| 551 |
else odd=0; |
| 552 |
|
| 553 |
for(i=0; i<s->mb_num; i++){ |
| 554 |
int mb_xy= s->mb_index2xy[i];
|
| 555 |
if((qscale_table[mb_xy]&1) != odd) |
| 556 |
qscale_table[mb_xy]++; |
| 557 |
if(qscale_table[mb_xy] > 31) |
| 558 |
qscale_table[mb_xy]= 31;
|
| 559 |
} |
| 560 |
|
| 561 |
for(i=1; i<s->mb_num; i++){ |
| 562 |
int mb_xy= s->mb_index2xy[i];
|
| 563 |
if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ |
| 564 |
s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR; |
| 565 |
} |
| 566 |
} |
| 567 |
} |
| 568 |
} |
| 569 |
|
| 570 |
#endif //CONFIG_ENCODERS |
| 571 |
|
| 572 |
#define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t))) |
| 573 |
#define tab_bias (tab_size/2) |
| 574 |
|
| 575 |
void ff_mpeg4_init_direct_mv(MpegEncContext *s){
|
| 576 |
int i;
|
| 577 |
for(i=0; i<tab_size; i++){ |
| 578 |
s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
|
| 579 |
s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
|
| 580 |
} |
| 581 |
} |
| 582 |
|
| 583 |
static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){ |
| 584 |
int xy= s->block_index[i];
|
| 585 |
uint16_t time_pp= s->pp_time; |
| 586 |
uint16_t time_pb= s->pb_time; |
| 587 |
int p_mx, p_my;
|
| 588 |
|
| 589 |
p_mx= s->next_picture.motion_val[0][xy][0]; |
| 590 |
if((unsigned)(p_mx + tab_bias) < tab_size){ |
| 591 |
s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; |
| 592 |
s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx |
| 593 |
: s->direct_scale_mv[1][p_mx + tab_bias];
|
| 594 |
}else{
|
| 595 |
s->mv[0][i][0] = p_mx*time_pb/time_pp + mx; |
| 596 |
s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx |
| 597 |
: p_mx*(time_pb - time_pp)/time_pp; |
| 598 |
} |
| 599 |
p_my= s->next_picture.motion_val[0][xy][1]; |
| 600 |
if((unsigned)(p_my + tab_bias) < tab_size){ |
| 601 |
s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; |
| 602 |
s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my |
| 603 |
: s->direct_scale_mv[1][p_my + tab_bias];
|
| 604 |
}else{
|
| 605 |
s->mv[0][i][1] = p_my*time_pb/time_pp + my; |
| 606 |
s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my |
| 607 |
: p_my*(time_pb - time_pp)/time_pp; |
| 608 |
} |
| 609 |
} |
| 610 |
|
| 611 |
#undef tab_size
|
| 612 |
#undef tab_bias
|
| 613 |
|
| 614 |
/**
|
| 615 |
*
|
| 616 |
* @return the mb_type
|
| 617 |
*/
|
| 618 |
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){ |
| 619 |
const int mb_index= s->mb_x + s->mb_y*s->mb_stride; |
| 620 |
const int colocated_mb_type= s->next_picture.mb_type[mb_index]; |
| 621 |
uint16_t time_pp= s->pp_time; |
| 622 |
uint16_t time_pb= s->pb_time; |
| 623 |
int i;
|
| 624 |
|
| 625 |
//FIXME avoid divides
|
| 626 |
// try special case with shifts for 1 and 3 B-frames?
|
| 627 |
|
| 628 |
if(IS_8X8(colocated_mb_type)){
|
| 629 |
s->mv_type = MV_TYPE_8X8; |
| 630 |
for(i=0; i<4; i++){ |
| 631 |
ff_mpeg4_set_one_direct_mv(s, mx, my, i); |
| 632 |
} |
| 633 |
return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
|
| 634 |
} else if(IS_INTERLACED(colocated_mb_type)){ |
| 635 |
s->mv_type = MV_TYPE_FIELD; |
| 636 |
for(i=0; i<2; i++){ |
| 637 |
int field_select= s->next_picture.ref_index[0][s->block_index[2*i]]; |
| 638 |
s->field_select[0][i]= field_select;
|
| 639 |
s->field_select[1][i]= i;
|
| 640 |
if(s->top_field_first){
|
| 641 |
time_pp= s->pp_field_time - field_select + i; |
| 642 |
time_pb= s->pb_field_time - field_select + i; |
| 643 |
}else{
|
| 644 |
time_pp= s->pp_field_time + field_select - i; |
| 645 |
time_pb= s->pb_field_time + field_select - i; |
| 646 |
} |
| 647 |
s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; |
| 648 |
s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; |
| 649 |
s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0] |
| 650 |
: s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp; |
| 651 |
s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] |
| 652 |
: s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp; |
| 653 |
} |
| 654 |
return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
|
| 655 |
}else{
|
| 656 |
ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
|
| 657 |
s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0]; |
| 658 |
s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1]; |
| 659 |
s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0]; |
| 660 |
s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1]; |
| 661 |
if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
|
| 662 |
s->mv_type= MV_TYPE_16X16; |
| 663 |
else
|
| 664 |
s->mv_type= MV_TYPE_8X8; |
| 665 |
return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
| 666 |
} |
| 667 |
} |
| 668 |
|
| 669 |
void ff_h263_update_motion_val(MpegEncContext * s){
|
| 670 |
const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; |
| 671 |
//FIXME a lot of that is only needed for !low_delay
|
| 672 |
const int wrap = s->b8_stride; |
| 673 |
const int xy = s->block_index[0]; |
| 674 |
|
| 675 |
s->current_picture.mbskip_table[mb_xy]= s->mb_skipped; |
| 676 |
|
| 677 |
if(s->mv_type != MV_TYPE_8X8){
|
| 678 |
int motion_x, motion_y;
|
| 679 |
if (s->mb_intra) {
|
| 680 |
motion_x = 0;
|
| 681 |
motion_y = 0;
|
| 682 |
} else if (s->mv_type == MV_TYPE_16X16) { |
| 683 |
motion_x = s->mv[0][0][0]; |
| 684 |
motion_y = s->mv[0][0][1]; |
| 685 |
} else /*if (s->mv_type == MV_TYPE_FIELD)*/ { |
| 686 |
int i;
|
| 687 |
motion_x = s->mv[0][0][0] + s->mv[0][1][0]; |
| 688 |
motion_y = s->mv[0][0][1] + s->mv[0][1][1]; |
| 689 |
motion_x = (motion_x>>1) | (motion_x&1); |
| 690 |
for(i=0; i<2; i++){ |
| 691 |
s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0]; |
| 692 |
s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1]; |
| 693 |
} |
| 694 |
s->current_picture.ref_index[0][xy ]=
|
| 695 |
s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0]; |
| 696 |
s->current_picture.ref_index[0][xy + wrap ]=
|
| 697 |
s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1]; |
| 698 |
} |
| 699 |
|
| 700 |
/* no update if 8X8 because it has been done during parsing */
|
| 701 |
s->current_picture.motion_val[0][xy][0] = motion_x; |
| 702 |
s->current_picture.motion_val[0][xy][1] = motion_y; |
| 703 |
s->current_picture.motion_val[0][xy + 1][0] = motion_x; |
| 704 |
s->current_picture.motion_val[0][xy + 1][1] = motion_y; |
| 705 |
s->current_picture.motion_val[0][xy + wrap][0] = motion_x; |
| 706 |
s->current_picture.motion_val[0][xy + wrap][1] = motion_y; |
| 707 |
s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x; |
| 708 |
s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; |
| 709 |
} |
| 710 |
|
| 711 |
if(s->encoding){ //FIXME encoding MUST be cleaned up |
| 712 |
if (s->mv_type == MV_TYPE_8X8)
|
| 713 |
s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; |
| 714 |
else if(s->mb_intra) |
| 715 |
s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; |
| 716 |
else
|
| 717 |
s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; |
| 718 |
} |
| 719 |
} |
| 720 |
|
| 721 |
#ifdef CONFIG_ENCODERS
|
| 722 |
|
| 723 |
static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){ |
| 724 |
int l, bit_size, code;
|
| 725 |
|
| 726 |
if (val == 0) { |
| 727 |
return mvtab[0][1]; |
| 728 |
} else {
|
| 729 |
bit_size = f_code - 1;
|
| 730 |
/* modulo encoding */
|
| 731 |
l= INT_BIT - 6 - bit_size;
|
| 732 |
val = (val<<l)>>l; |
| 733 |
val--; |
| 734 |
code = (val >> bit_size) + 1;
|
| 735 |
|
| 736 |
return mvtab[code][1] + 1 + bit_size; |
| 737 |
} |
| 738 |
} |
| 739 |
|
| 740 |
static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){ |
| 741 |
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
|
| 742 |
skip_put_bits(&s->pb, |
| 743 |
h263_get_motion_length(s, x, f_code) |
| 744 |
+h263_get_motion_length(s, y, f_code)); |
| 745 |
}else{
|
| 746 |
ff_h263_encode_motion(s, x, f_code); |
| 747 |
ff_h263_encode_motion(s, y, f_code); |
| 748 |
} |
| 749 |
} |
| 750 |
|
| 751 |
static inline int get_p_cbp(MpegEncContext * s, |
| 752 |
DCTELEM block[6][64], |
| 753 |
int motion_x, int motion_y){ |
| 754 |
int cbp, i;
|
| 755 |
|
| 756 |
if(s->flags & CODEC_FLAG_CBP_RD){
|
| 757 |
int best_cbpy_score= INT_MAX;
|
| 758 |
int best_cbpc_score= INT_MAX;
|
| 759 |
int cbpc = (-1), cbpy= (-1); |
| 760 |
const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0); |
| 761 |
const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
| 762 |
|
| 763 |
for(i=0; i<4; i++){ |
| 764 |
int score= inter_MCBPC_bits[i + offset] * lambda;
|
| 765 |
if(i&1) score += s->coded_score[5]; |
| 766 |
if(i&2) score += s->coded_score[4]; |
| 767 |
|
| 768 |
if(score < best_cbpc_score){
|
| 769 |
best_cbpc_score= score; |
| 770 |
cbpc= i; |
| 771 |
} |
| 772 |
} |
| 773 |
|
| 774 |
for(i=0; i<16; i++){ |
| 775 |
int score= cbpy_tab[i ^ 0xF][1] * lambda; |
| 776 |
if(i&1) score += s->coded_score[3]; |
| 777 |
if(i&2) score += s->coded_score[2]; |
| 778 |
if(i&4) score += s->coded_score[1]; |
| 779 |
if(i&8) score += s->coded_score[0]; |
| 780 |
|
| 781 |
if(score < best_cbpy_score){
|
| 782 |
best_cbpy_score= score; |
| 783 |
cbpy= i; |
| 784 |
} |
| 785 |
} |
| 786 |
cbp= cbpc + 4*cbpy;
|
| 787 |
if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){ |
| 788 |
if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0) |
| 789 |
cbp= 0;
|
| 790 |
} |
| 791 |
|
| 792 |
for (i = 0; i < 6; i++) { |
| 793 |
if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ |
| 794 |
s->block_last_index[i]= -1;
|
| 795 |
memset(s->block[i], 0, sizeof(DCTELEM)*64); |
| 796 |
} |
| 797 |
} |
| 798 |
}else{
|
| 799 |
cbp= 0;
|
| 800 |
for (i = 0; i < 6; i++) { |
| 801 |
if (s->block_last_index[i] >= 0) |
| 802 |
cbp |= 1 << (5 - i); |
| 803 |
} |
| 804 |
} |
| 805 |
return cbp;
|
| 806 |
} |
| 807 |
|
| 808 |
static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64], |
| 809 |
int motion_x, int motion_y, int mb_type){ |
| 810 |
int cbp=0, i; |
| 811 |
|
| 812 |
if(s->flags & CODEC_FLAG_CBP_RD){
|
| 813 |
int score=0; |
| 814 |
const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
| 815 |
|
| 816 |
for(i=0; i<6; i++){ |
| 817 |
if(s->coded_score[i] < 0){ |
| 818 |
score += s->coded_score[i]; |
| 819 |
cbp |= 1 << (5 - i); |
| 820 |
} |
| 821 |
} |
| 822 |
|
| 823 |
if(cbp){
|
| 824 |
int zero_score= -6; |
| 825 |
if ((motion_x | motion_y | s->dquant | mb_type) == 0){ |
| 826 |
zero_score-= 4; //2*MV + mb_type + cbp bit |
| 827 |
} |
| 828 |
|
| 829 |
zero_score*= lambda; |
| 830 |
if(zero_score <= score){
|
| 831 |
cbp=0;
|
| 832 |
} |
| 833 |
} |
| 834 |
|
| 835 |
for (i = 0; i < 6; i++) { |
| 836 |
if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ |
| 837 |
s->block_last_index[i]= -1;
|
| 838 |
memset(s->block[i], 0, sizeof(DCTELEM)*64); |
| 839 |
} |
| 840 |
} |
| 841 |
}else{
|
| 842 |
for (i = 0; i < 6; i++) { |
| 843 |
if (s->block_last_index[i] >= 0) |
| 844 |
cbp |= 1 << (5 - i); |
| 845 |
} |
| 846 |
} |
| 847 |
return cbp;
|
| 848 |
} |
| 849 |
|
| 850 |
static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], |
| 851 |
uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
|
| 852 |
int i;
|
| 853 |
|
| 854 |
if(scan_table){
|
| 855 |
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
|
| 856 |
for (i = 0; i < 6; i++) { |
| 857 |
skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i])); |
| 858 |
} |
| 859 |
}else{
|
| 860 |
/* encode each block */
|
| 861 |
for (i = 0; i < 6; i++) { |
| 862 |
mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb); |
| 863 |
} |
| 864 |
} |
| 865 |
}else{
|
| 866 |
if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
|
| 867 |
for (i = 0; i < 6; i++) { |
| 868 |
skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
|
| 869 |
} |
| 870 |
}else{
|
| 871 |
/* encode each block */
|
| 872 |
for (i = 0; i < 6; i++) { |
| 873 |
mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
|
| 874 |
} |
| 875 |
} |
| 876 |
} |
| 877 |
} |
| 878 |
|
| 879 |
void mpeg4_encode_mb(MpegEncContext * s,
|
| 880 |
DCTELEM block[6][64], |
| 881 |
int motion_x, int motion_y) |
| 882 |
{
|
| 883 |
int cbpc, cbpy, pred_x, pred_y;
|
| 884 |
PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
|
| 885 |
PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
|
| 886 |
PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
|
| 887 |
const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; |
| 888 |
const int dquant_code[5]= {1,0,9,2,3}; |
| 889 |
|
| 890 |
// printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
|
| 891 |
if (!s->mb_intra) {
|
| 892 |
int i, cbp;
|
| 893 |
|
| 894 |
if(s->pict_type==B_TYPE){
|
| 895 |
static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ |
| 896 |
int mb_type= mb_type_table[s->mv_dir];
|
| 897 |
|
| 898 |
if(s->mb_x==0){ |
| 899 |
for(i=0; i<2; i++){ |
| 900 |
s->last_mv[i][0][0]= |
| 901 |
s->last_mv[i][0][1]= |
| 902 |
s->last_mv[i][1][0]= |
| 903 |
s->last_mv[i][1][1]= 0; |
| 904 |
} |
| 905 |
} |
| 906 |
|
| 907 |
assert(s->dquant>=-2 && s->dquant<=2); |
| 908 |
assert((s->dquant&1)==0); |
| 909 |
assert(mb_type>=0);
|
| 910 |
|
| 911 |
/* nothing to do if this MB was skipped in the next P Frame */
|
| 912 |
if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
| 913 |
s->skip_count++; |
| 914 |
s->mv[0][0][0]= |
| 915 |
s->mv[0][0][1]= |
| 916 |
s->mv[1][0][0]= |
| 917 |
s->mv[1][0][1]= 0; |
| 918 |
s->mv_dir= MV_DIR_FORWARD; //doesn't matter
|
| 919 |
s->qscale -= s->dquant; |
| 920 |
// s->mb_skipped=1;
|
| 921 |
|
| 922 |
return;
|
| 923 |
} |
| 924 |
|
| 925 |
cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); |
| 926 |
|
| 927 |
if ((cbp | motion_x | motion_y | mb_type) ==0) { |
| 928 |
/* direct MB with MV={0,0} */
|
| 929 |
assert(s->dquant==0);
|
| 930 |
|
| 931 |
put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
| 932 |
|
| 933 |
if(interleaved_stats){
|
| 934 |
s->misc_bits++; |
| 935 |
s->last_bits++; |
| 936 |
} |
| 937 |
s->skip_count++; |
| 938 |
return;
|
| 939 |
} |
| 940 |
|
| 941 |
put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
| 942 |
put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge |
| 943 |
put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) |
| 944 |
if(cbp) put_bits(&s->pb, 6, cbp); |
| 945 |
|
| 946 |
if(cbp && mb_type){
|
| 947 |
if(s->dquant)
|
| 948 |
put_bits(&s->pb, 2, (s->dquant>>2)+3); |
| 949 |
else
|
| 950 |
put_bits(&s->pb, 1, 0); |
| 951 |
}else
|
| 952 |
s->qscale -= s->dquant; |
| 953 |
|
| 954 |
if(!s->progressive_sequence){
|
| 955 |
if(cbp)
|
| 956 |
put_bits(&s->pb, 1, s->interlaced_dct);
|
| 957 |
if(mb_type) // not direct mode |
| 958 |
put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
|
| 959 |
} |
| 960 |
|
| 961 |
if(interleaved_stats){
|
| 962 |
s->misc_bits+= get_bits_diff(s); |
| 963 |
} |
| 964 |
|
| 965 |
if(mb_type == 0){ |
| 966 |
assert(s->mv_dir & MV_DIRECT); |
| 967 |
ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
|
| 968 |
s->b_count++; |
| 969 |
s->f_count++; |
| 970 |
}else{
|
| 971 |
assert(mb_type > 0 && mb_type < 4); |
| 972 |
if(s->mv_type != MV_TYPE_FIELD){
|
| 973 |
if(s->mv_dir & MV_DIR_FORWARD){
|
| 974 |
ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0], |
| 975 |
s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); |
| 976 |
s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0]; |
| 977 |
s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1]; |
| 978 |
s->f_count++; |
| 979 |
} |
| 980 |
if(s->mv_dir & MV_DIR_BACKWARD){
|
| 981 |
ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0], |
| 982 |
s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); |
| 983 |
s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0]; |
| 984 |
s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1]; |
| 985 |
s->b_count++; |
| 986 |
} |
| 987 |
}else{
|
| 988 |
if(s->mv_dir & MV_DIR_FORWARD){
|
| 989 |
put_bits(&s->pb, 1, s->field_select[0][0]); |
| 990 |
put_bits(&s->pb, 1, s->field_select[0][1]); |
| 991 |
} |
| 992 |
if(s->mv_dir & MV_DIR_BACKWARD){
|
| 993 |
put_bits(&s->pb, 1, s->field_select[1][0]); |
| 994 |
put_bits(&s->pb, 1, s->field_select[1][1]); |
| 995 |
} |
| 996 |
if(s->mv_dir & MV_DIR_FORWARD){
|
| 997 |
for(i=0; i<2; i++){ |
| 998 |
ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] , |
| 999 |
s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code); |
| 1000 |
s->last_mv[0][i][0]= s->mv[0][i][0]; |
| 1001 |
s->last_mv[0][i][1]= s->mv[0][i][1]*2; |
| 1002 |
} |
| 1003 |
s->f_count++; |
| 1004 |
} |
| 1005 |
if(s->mv_dir & MV_DIR_BACKWARD){
|
| 1006 |
for(i=0; i<2; i++){ |
| 1007 |
ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] , |
| 1008 |
s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code); |
| 1009 |
s->last_mv[1][i][0]= s->mv[1][i][0]; |
| 1010 |
s->last_mv[1][i][1]= s->mv[1][i][1]*2; |
| 1011 |
} |
| 1012 |
s->b_count++; |
| 1013 |
} |
| 1014 |
} |
| 1015 |
} |
| 1016 |
|
| 1017 |
if(interleaved_stats){
|
| 1018 |
s->mv_bits+= get_bits_diff(s); |
| 1019 |
} |
| 1020 |
|
| 1021 |
mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb); |
| 1022 |
|
| 1023 |
if(interleaved_stats){
|
| 1024 |
s->p_tex_bits+= get_bits_diff(s); |
| 1025 |
} |
| 1026 |
|
| 1027 |
}else{ /* s->pict_type==B_TYPE */ |
| 1028 |
cbp= get_p_cbp(s, block, motion_x, motion_y); |
| 1029 |
|
| 1030 |
if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
| 1031 |
/* check if the B frames can skip it too, as we must skip it if we skip here
|
| 1032 |
why didn't they just compress the skip-mb bits instead of reusing them ?! */
|
| 1033 |
if(s->max_b_frames>0){ |
| 1034 |
int i;
|
| 1035 |
int x,y, offset;
|
| 1036 |
uint8_t *p_pic; |
| 1037 |
|
| 1038 |
x= s->mb_x*16;
|
| 1039 |
y= s->mb_y*16;
|
| 1040 |
if(x+16 > s->width) x= s->width-16; |
| 1041 |
if(y+16 > s->height) y= s->height-16; |
| 1042 |
|
| 1043 |
offset= x + y*s->linesize; |
| 1044 |
p_pic= s->new_picture.data[0] + offset;
|
| 1045 |
|
| 1046 |
s->mb_skipped=1;
|
| 1047 |
for(i=0; i<s->max_b_frames; i++){ |
| 1048 |
uint8_t *b_pic; |
| 1049 |
int diff;
|
| 1050 |
Picture *pic= s->reordered_input_picture[i+1];
|
| 1051 |
|
| 1052 |
if(pic==NULL || pic->pict_type!=B_TYPE) break; |
| 1053 |
|
| 1054 |
b_pic= pic->data[0] + offset;
|
| 1055 |
if(pic->type != FF_BUFFER_TYPE_SHARED)
|
| 1056 |
b_pic+= INPLACE_OFFSET; |
| 1057 |
diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16); |
| 1058 |
if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
| 1059 |
s->mb_skipped=0;
|
| 1060 |
break;
|
| 1061 |
} |
| 1062 |
} |
| 1063 |
}else
|
| 1064 |
s->mb_skipped=1;
|
| 1065 |
|
| 1066 |
if(s->mb_skipped==1){ |
| 1067 |
/* skip macroblock */
|
| 1068 |
put_bits(&s->pb, 1, 1); |
| 1069 |
|
| 1070 |
if(interleaved_stats){
|
| 1071 |
s->misc_bits++; |
| 1072 |
s->last_bits++; |
| 1073 |
} |
| 1074 |
s->skip_count++; |
| 1075 |
|
| 1076 |
return;
|
| 1077 |
} |
| 1078 |
} |
| 1079 |
|
| 1080 |
put_bits(&s->pb, 1, 0); /* mb coded */ |
| 1081 |
cbpc = cbp & 3;
|
| 1082 |
cbpy = cbp >> 2;
|
| 1083 |
cbpy ^= 0xf;
|
| 1084 |
if(s->mv_type==MV_TYPE_16X16){
|
| 1085 |
if(s->dquant) cbpc+= 8; |
| 1086 |
put_bits(&s->pb, |
| 1087 |
inter_MCBPC_bits[cbpc], |
| 1088 |
inter_MCBPC_code[cbpc]); |
| 1089 |
|
| 1090 |
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
| 1091 |
if(s->dquant)
|
| 1092 |
put_bits(pb2, 2, dquant_code[s->dquant+2]); |
| 1093 |
|
| 1094 |
if(!s->progressive_sequence){
|
| 1095 |
if(cbp)
|
| 1096 |
put_bits(pb2, 1, s->interlaced_dct);
|
| 1097 |
put_bits(pb2, 1, 0); |
| 1098 |
} |
| 1099 |
|
| 1100 |
if(interleaved_stats){
|
| 1101 |
s->misc_bits+= get_bits_diff(s); |
| 1102 |
} |
| 1103 |
|
| 1104 |
/* motion vectors: 16x16 mode */
|
| 1105 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 1106 |
|
| 1107 |
ff_h263_encode_motion_vector(s, motion_x - pred_x, |
| 1108 |
motion_y - pred_y, s->f_code); |
| 1109 |
}else if(s->mv_type==MV_TYPE_FIELD){ |
| 1110 |
if(s->dquant) cbpc+= 8; |
| 1111 |
put_bits(&s->pb, |
| 1112 |
inter_MCBPC_bits[cbpc], |
| 1113 |
inter_MCBPC_code[cbpc]); |
| 1114 |
|
| 1115 |
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
| 1116 |
if(s->dquant)
|
| 1117 |
put_bits(pb2, 2, dquant_code[s->dquant+2]); |
| 1118 |
|
| 1119 |
assert(!s->progressive_sequence); |
| 1120 |
if(cbp)
|
| 1121 |
put_bits(pb2, 1, s->interlaced_dct);
|
| 1122 |
put_bits(pb2, 1, 1); |
| 1123 |
|
| 1124 |
if(interleaved_stats){
|
| 1125 |
s->misc_bits+= get_bits_diff(s); |
| 1126 |
} |
| 1127 |
|
| 1128 |
/* motion vectors: 16x8 interlaced mode */
|
| 1129 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 1130 |
pred_y /=2;
|
| 1131 |
|
| 1132 |
put_bits(&s->pb, 1, s->field_select[0][0]); |
| 1133 |
put_bits(&s->pb, 1, s->field_select[0][1]); |
| 1134 |
|
| 1135 |
ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x, |
| 1136 |
s->mv[0][0][1] - pred_y, s->f_code); |
| 1137 |
ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x, |
| 1138 |
s->mv[0][1][1] - pred_y, s->f_code); |
| 1139 |
}else{
|
| 1140 |
assert(s->mv_type==MV_TYPE_8X8); |
| 1141 |
put_bits(&s->pb, |
| 1142 |
inter_MCBPC_bits[cbpc+16],
|
| 1143 |
inter_MCBPC_code[cbpc+16]);
|
| 1144 |
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
| 1145 |
|
| 1146 |
if(!s->progressive_sequence){
|
| 1147 |
if(cbp)
|
| 1148 |
put_bits(pb2, 1, s->interlaced_dct);
|
| 1149 |
} |
| 1150 |
|
| 1151 |
if(interleaved_stats){
|
| 1152 |
s->misc_bits+= get_bits_diff(s); |
| 1153 |
} |
| 1154 |
|
| 1155 |
for(i=0; i<4; i++){ |
| 1156 |
/* motion vectors: 8x8 mode*/
|
| 1157 |
h263_pred_motion(s, i, 0, &pred_x, &pred_y);
|
| 1158 |
|
| 1159 |
ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, |
| 1160 |
s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); |
| 1161 |
} |
| 1162 |
} |
| 1163 |
|
| 1164 |
if(interleaved_stats){
|
| 1165 |
s->mv_bits+= get_bits_diff(s); |
| 1166 |
} |
| 1167 |
|
| 1168 |
mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb); |
| 1169 |
|
| 1170 |
if(interleaved_stats){
|
| 1171 |
s->p_tex_bits+= get_bits_diff(s); |
| 1172 |
} |
| 1173 |
s->f_count++; |
| 1174 |
} |
| 1175 |
} else {
|
| 1176 |
int cbp;
|
| 1177 |
int dc_diff[6]; //dc values with the dc prediction subtracted |
| 1178 |
int dir[6]; //prediction direction |
| 1179 |
int zigzag_last_index[6]; |
| 1180 |
uint8_t *scan_table[6];
|
| 1181 |
int i;
|
| 1182 |
|
| 1183 |
for(i=0; i<6; i++){ |
| 1184 |
dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); |
| 1185 |
} |
| 1186 |
|
| 1187 |
if(s->flags & CODEC_FLAG_AC_PRED){
|
| 1188 |
s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); |
| 1189 |
if(!s->ac_pred)
|
| 1190 |
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); |
| 1191 |
}else{
|
| 1192 |
for(i=0; i<6; i++) |
| 1193 |
scan_table[i]= s->intra_scantable.permutated; |
| 1194 |
} |
| 1195 |
|
| 1196 |
/* compute cbp */
|
| 1197 |
cbp = 0;
|
| 1198 |
for (i = 0; i < 6; i++) { |
| 1199 |
if (s->block_last_index[i] >= 1) |
| 1200 |
cbp |= 1 << (5 - i); |
| 1201 |
} |
| 1202 |
|
| 1203 |
cbpc = cbp & 3;
|
| 1204 |
if (s->pict_type == I_TYPE) {
|
| 1205 |
if(s->dquant) cbpc+=4; |
| 1206 |
put_bits(&s->pb, |
| 1207 |
intra_MCBPC_bits[cbpc], |
| 1208 |
intra_MCBPC_code[cbpc]); |
| 1209 |
} else {
|
| 1210 |
if(s->dquant) cbpc+=8; |
| 1211 |
put_bits(&s->pb, 1, 0); /* mb coded */ |
| 1212 |
put_bits(&s->pb, |
| 1213 |
inter_MCBPC_bits[cbpc + 4],
|
| 1214 |
inter_MCBPC_code[cbpc + 4]);
|
| 1215 |
} |
| 1216 |
put_bits(pb2, 1, s->ac_pred);
|
| 1217 |
cbpy = cbp >> 2;
|
| 1218 |
put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
| 1219 |
if(s->dquant)
|
| 1220 |
put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
| 1221 |
|
| 1222 |
if(!s->progressive_sequence){
|
| 1223 |
put_bits(dc_pb, 1, s->interlaced_dct);
|
| 1224 |
} |
| 1225 |
|
| 1226 |
if(interleaved_stats){
|
| 1227 |
s->misc_bits+= get_bits_diff(s); |
| 1228 |
} |
| 1229 |
|
| 1230 |
mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb); |
| 1231 |
|
| 1232 |
if(interleaved_stats){
|
| 1233 |
s->i_tex_bits+= get_bits_diff(s); |
| 1234 |
} |
| 1235 |
s->i_count++; |
| 1236 |
|
| 1237 |
/* restore ac coeffs & last_index stuff if we messed them up with the prediction */
|
| 1238 |
if(s->ac_pred)
|
| 1239 |
restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); |
| 1240 |
} |
| 1241 |
} |
| 1242 |
|
| 1243 |
void h263_encode_mb(MpegEncContext * s,
|
| 1244 |
DCTELEM block[6][64], |
| 1245 |
int motion_x, int motion_y) |
| 1246 |
{
|
| 1247 |
int cbpc, cbpy, i, cbp, pred_x, pred_y;
|
| 1248 |
int16_t pred_dc; |
| 1249 |
int16_t rec_intradc[6];
|
| 1250 |
int16_t *dc_ptr[6];
|
| 1251 |
const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
| 1252 |
const int dquant_code[5]= {1,0,9,2,3}; |
| 1253 |
|
| 1254 |
//printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
|
| 1255 |
if (!s->mb_intra) {
|
| 1256 |
/* compute cbp */
|
| 1257 |
cbp= get_p_cbp(s, block, motion_x, motion_y); |
| 1258 |
|
| 1259 |
if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) { |
| 1260 |
/* skip macroblock */
|
| 1261 |
put_bits(&s->pb, 1, 1); |
| 1262 |
if(interleaved_stats){
|
| 1263 |
s->misc_bits++; |
| 1264 |
s->last_bits++; |
| 1265 |
} |
| 1266 |
s->skip_count++; |
| 1267 |
|
| 1268 |
return;
|
| 1269 |
} |
| 1270 |
put_bits(&s->pb, 1, 0); /* mb coded */ |
| 1271 |
|
| 1272 |
cbpc = cbp & 3;
|
| 1273 |
cbpy = cbp >> 2;
|
| 1274 |
if(s->alt_inter_vlc==0 || cbpc!=3) |
| 1275 |
cbpy ^= 0xF;
|
| 1276 |
if(s->dquant) cbpc+= 8; |
| 1277 |
if(s->mv_type==MV_TYPE_16X16){
|
| 1278 |
put_bits(&s->pb, |
| 1279 |
inter_MCBPC_bits[cbpc], |
| 1280 |
inter_MCBPC_code[cbpc]); |
| 1281 |
|
| 1282 |
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
| 1283 |
if(s->dquant)
|
| 1284 |
put_bits(&s->pb, 2, dquant_code[s->dquant+2]); |
| 1285 |
|
| 1286 |
if(interleaved_stats){
|
| 1287 |
s->misc_bits+= get_bits_diff(s); |
| 1288 |
} |
| 1289 |
|
| 1290 |
/* motion vectors: 16x16 mode */
|
| 1291 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 1292 |
|
| 1293 |
if (!s->umvplus) {
|
| 1294 |
ff_h263_encode_motion_vector(s, motion_x - pred_x, |
| 1295 |
motion_y - pred_y, 1);
|
| 1296 |
} |
| 1297 |
else {
|
| 1298 |
h263p_encode_umotion(s, motion_x - pred_x); |
| 1299 |
h263p_encode_umotion(s, motion_y - pred_y); |
| 1300 |
if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) |
| 1301 |
/* To prevent Start Code emulation */
|
| 1302 |
put_bits(&s->pb,1,1); |
| 1303 |
} |
| 1304 |
}else{
|
| 1305 |
put_bits(&s->pb, |
| 1306 |
inter_MCBPC_bits[cbpc+16],
|
| 1307 |
inter_MCBPC_code[cbpc+16]);
|
| 1308 |
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
| 1309 |
if(s->dquant)
|
| 1310 |
put_bits(&s->pb, 2, dquant_code[s->dquant+2]); |
| 1311 |
|
| 1312 |
if(interleaved_stats){
|
| 1313 |
s->misc_bits+= get_bits_diff(s); |
| 1314 |
} |
| 1315 |
|
| 1316 |
for(i=0; i<4; i++){ |
| 1317 |
/* motion vectors: 8x8 mode*/
|
| 1318 |
h263_pred_motion(s, i, 0, &pred_x, &pred_y);
|
| 1319 |
|
| 1320 |
motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0]; |
| 1321 |
motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
| 1322 |
if (!s->umvplus) {
|
| 1323 |
ff_h263_encode_motion_vector(s, motion_x - pred_x, |
| 1324 |
motion_y - pred_y, 1);
|
| 1325 |
} |
| 1326 |
else {
|
| 1327 |
h263p_encode_umotion(s, motion_x - pred_x); |
| 1328 |
h263p_encode_umotion(s, motion_y - pred_y); |
| 1329 |
if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) |
| 1330 |
/* To prevent Start Code emulation */
|
| 1331 |
put_bits(&s->pb,1,1); |
| 1332 |
} |
| 1333 |
} |
| 1334 |
} |
| 1335 |
|
| 1336 |
if(interleaved_stats){
|
| 1337 |
s->mv_bits+= get_bits_diff(s); |
| 1338 |
} |
| 1339 |
} else {
|
| 1340 |
assert(s->mb_intra); |
| 1341 |
|
| 1342 |
cbp = 0;
|
| 1343 |
if (s->h263_aic) {
|
| 1344 |
/* Predict DC */
|
| 1345 |
for(i=0; i<6; i++) { |
| 1346 |
int16_t level = block[i][0];
|
| 1347 |
int scale;
|
| 1348 |
|
| 1349 |
if(i<4) scale= s->y_dc_scale; |
| 1350 |
else scale= s->c_dc_scale;
|
| 1351 |
|
| 1352 |
pred_dc = h263_pred_dc(s, i, &dc_ptr[i]); |
| 1353 |
level -= pred_dc; |
| 1354 |
/* Quant */
|
| 1355 |
if (level >= 0) |
| 1356 |
level = (level + (scale>>1))/scale;
|
| 1357 |
else
|
| 1358 |
level = (level - (scale>>1))/scale;
|
| 1359 |
|
| 1360 |
/* AIC can change CBP */
|
| 1361 |
if (level == 0 && s->block_last_index[i] == 0) |
| 1362 |
s->block_last_index[i] = -1;
|
| 1363 |
|
| 1364 |
if(!s->modified_quant){
|
| 1365 |
if (level < -127) |
| 1366 |
level = -127;
|
| 1367 |
else if (level > 127) |
| 1368 |
level = 127;
|
| 1369 |
} |
| 1370 |
|
| 1371 |
block[i][0] = level;
|
| 1372 |
/* Reconstruction */
|
| 1373 |
rec_intradc[i] = scale*level + pred_dc; |
| 1374 |
/* Oddify */
|
| 1375 |
rec_intradc[i] |= 1;
|
| 1376 |
//if ((rec_intradc[i] % 2) == 0)
|
| 1377 |
// rec_intradc[i]++;
|
| 1378 |
/* Clipping */
|
| 1379 |
if (rec_intradc[i] < 0) |
| 1380 |
rec_intradc[i] = 0;
|
| 1381 |
else if (rec_intradc[i] > 2047) |
| 1382 |
rec_intradc[i] = 2047;
|
| 1383 |
|
| 1384 |
/* Update AC/DC tables */
|
| 1385 |
*dc_ptr[i] = rec_intradc[i]; |
| 1386 |
if (s->block_last_index[i] >= 0) |
| 1387 |
cbp |= 1 << (5 - i); |
| 1388 |
} |
| 1389 |
}else{
|
| 1390 |
for(i=0; i<6; i++) { |
| 1391 |
/* compute cbp */
|
| 1392 |
if (s->block_last_index[i] >= 1) |
| 1393 |
cbp |= 1 << (5 - i); |
| 1394 |
} |
| 1395 |
} |
| 1396 |
|
| 1397 |
cbpc = cbp & 3;
|
| 1398 |
if (s->pict_type == I_TYPE) {
|
| 1399 |
if(s->dquant) cbpc+=4; |
| 1400 |
put_bits(&s->pb, |
| 1401 |
intra_MCBPC_bits[cbpc], |
| 1402 |
intra_MCBPC_code[cbpc]); |
| 1403 |
} else {
|
| 1404 |
if(s->dquant) cbpc+=8; |
| 1405 |
put_bits(&s->pb, 1, 0); /* mb coded */ |
| 1406 |
put_bits(&s->pb, |
| 1407 |
inter_MCBPC_bits[cbpc + 4],
|
| 1408 |
inter_MCBPC_code[cbpc + 4]);
|
| 1409 |
} |
| 1410 |
if (s->h263_aic) {
|
| 1411 |
/* XXX: currently, we do not try to use ac prediction */
|
| 1412 |
put_bits(&s->pb, 1, 0); /* no AC prediction */ |
| 1413 |
} |
| 1414 |
cbpy = cbp >> 2;
|
| 1415 |
put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
| 1416 |
if(s->dquant)
|
| 1417 |
put_bits(&s->pb, 2, dquant_code[s->dquant+2]); |
| 1418 |
|
| 1419 |
if(interleaved_stats){
|
| 1420 |
s->misc_bits+= get_bits_diff(s); |
| 1421 |
} |
| 1422 |
} |
| 1423 |
|
| 1424 |
for(i=0; i<6; i++) { |
| 1425 |
/* encode each block */
|
| 1426 |
h263_encode_block(s, block[i], i); |
| 1427 |
|
| 1428 |
/* Update INTRADC for decoding */
|
| 1429 |
if (s->h263_aic && s->mb_intra) {
|
| 1430 |
block[i][0] = rec_intradc[i];
|
| 1431 |
|
| 1432 |
} |
| 1433 |
} |
| 1434 |
|
| 1435 |
if(interleaved_stats){
|
| 1436 |
if (!s->mb_intra) {
|
| 1437 |
s->p_tex_bits+= get_bits_diff(s); |
| 1438 |
s->f_count++; |
| 1439 |
}else{
|
| 1440 |
s->i_tex_bits+= get_bits_diff(s); |
| 1441 |
s->i_count++; |
| 1442 |
} |
| 1443 |
} |
| 1444 |
} |
| 1445 |
#endif
|
| 1446 |
|
| 1447 |
void ff_h263_loop_filter(MpegEncContext * s){
|
| 1448 |
int qp_c;
|
| 1449 |
const int linesize = s->linesize; |
| 1450 |
const int uvlinesize= s->uvlinesize; |
| 1451 |
const int xy = s->mb_y * s->mb_stride + s->mb_x; |
| 1452 |
uint8_t *dest_y = s->dest[0];
|
| 1453 |
uint8_t *dest_cb= s->dest[1];
|
| 1454 |
uint8_t *dest_cr= s->dest[2];
|
| 1455 |
|
| 1456 |
// if(s->pict_type==B_TYPE && !s->readable) return;
|
| 1457 |
|
| 1458 |
/*
|
| 1459 |
Diag Top
|
| 1460 |
Left Center
|
| 1461 |
*/
|
| 1462 |
if(!IS_SKIP(s->current_picture.mb_type[xy])){
|
| 1463 |
qp_c= s->qscale; |
| 1464 |
s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
|
| 1465 |
s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); |
| 1466 |
}else
|
| 1467 |
qp_c= 0;
|
| 1468 |
|
| 1469 |
if(s->mb_y){
|
| 1470 |
int qp_dt, qp_t, qp_tc;
|
| 1471 |
|
| 1472 |
if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
|
| 1473 |
qp_t=0;
|
| 1474 |
else
|
| 1475 |
qp_t= s->current_picture.qscale_table[xy-s->mb_stride]; |
| 1476 |
|
| 1477 |
if(qp_c)
|
| 1478 |
qp_tc= qp_c; |
| 1479 |
else
|
| 1480 |
qp_tc= qp_t; |
| 1481 |
|
| 1482 |
if(qp_tc){
|
| 1483 |
const int chroma_qp= s->chroma_qscale_table[qp_tc]; |
| 1484 |
s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); |
| 1485 |
s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
|
| 1486 |
|
| 1487 |
s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); |
| 1488 |
s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); |
| 1489 |
} |
| 1490 |
|
| 1491 |
if(qp_t)
|
| 1492 |
s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t); |
| 1493 |
|
| 1494 |
if(s->mb_x){
|
| 1495 |
if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride])) |
| 1496 |
qp_dt= qp_t; |
| 1497 |
else
|
| 1498 |
qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
|
| 1499 |
|
| 1500 |
if(qp_dt){
|
| 1501 |
const int chroma_qp= s->chroma_qscale_table[qp_dt]; |
| 1502 |
s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
|
| 1503 |
s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
|
| 1504 |
s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
|
| 1505 |
} |
| 1506 |
} |
| 1507 |
} |
| 1508 |
|
| 1509 |
if(qp_c){
|
| 1510 |
s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
|
| 1511 |
if(s->mb_y + 1 == s->mb_height) |
| 1512 |
s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); |
| 1513 |
} |
| 1514 |
|
| 1515 |
if(s->mb_x){
|
| 1516 |
int qp_lc;
|
| 1517 |
if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1])) |
| 1518 |
qp_lc= qp_c; |
| 1519 |
else
|
| 1520 |
qp_lc= s->current_picture.qscale_table[xy-1];
|
| 1521 |
|
| 1522 |
if(qp_lc){
|
| 1523 |
s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); |
| 1524 |
if(s->mb_y + 1 == s->mb_height){ |
| 1525 |
const int chroma_qp= s->chroma_qscale_table[qp_lc]; |
| 1526 |
s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
|
| 1527 |
s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); |
| 1528 |
s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); |
| 1529 |
} |
| 1530 |
} |
| 1531 |
} |
| 1532 |
} |
| 1533 |
|
| 1534 |
#ifdef CONFIG_ENCODERS
|
| 1535 |
static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr) |
| 1536 |
{
|
| 1537 |
int x, y, wrap, a, c, pred_dc, scale;
|
| 1538 |
int16_t *dc_val; |
| 1539 |
|
| 1540 |
/* find prediction */
|
| 1541 |
if (n < 4) { |
| 1542 |
x = 2 * s->mb_x + (n & 1); |
| 1543 |
y = 2 * s->mb_y + ((n & 2) >> 1); |
| 1544 |
wrap = s->b8_stride; |
| 1545 |
dc_val = s->dc_val[0];
|
| 1546 |
scale = s->y_dc_scale; |
| 1547 |
} else {
|
| 1548 |
x = s->mb_x; |
| 1549 |
y = s->mb_y; |
| 1550 |
wrap = s->mb_stride; |
| 1551 |
dc_val = s->dc_val[n - 4 + 1]; |
| 1552 |
scale = s->c_dc_scale; |
| 1553 |
} |
| 1554 |
/* B C
|
| 1555 |
* A X
|
| 1556 |
*/
|
| 1557 |
a = dc_val[(x - 1) + (y) * wrap];
|
| 1558 |
c = dc_val[(x) + (y - 1) * wrap];
|
| 1559 |
|
| 1560 |
/* No prediction outside GOB boundary */
|
| 1561 |
if(s->first_slice_line && n!=3){ |
| 1562 |
if(n!=2) c= 1024; |
| 1563 |
if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; |
| 1564 |
} |
| 1565 |
pred_dc = 1024;
|
| 1566 |
/* just DC prediction */
|
| 1567 |
if (a != 1024 && c != 1024) |
| 1568 |
pred_dc = (a + c) >> 1;
|
| 1569 |
else if (a != 1024) |
| 1570 |
pred_dc = a; |
| 1571 |
else
|
| 1572 |
pred_dc = c; |
| 1573 |
|
| 1574 |
/* we assume pred is positive */
|
| 1575 |
//pred_dc = (pred_dc + (scale >> 1)) / scale;
|
| 1576 |
*dc_val_ptr = &dc_val[x + y * wrap]; |
| 1577 |
return pred_dc;
|
| 1578 |
} |
| 1579 |
#endif /* CONFIG_ENCODERS */ |
| 1580 |
|
| 1581 |
static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n) |
| 1582 |
{
|
| 1583 |
int x, y, wrap, a, c, pred_dc, scale, i;
|
| 1584 |
int16_t *dc_val, *ac_val, *ac_val1; |
| 1585 |
|
| 1586 |
/* find prediction */
|
| 1587 |
if (n < 4) { |
| 1588 |
x = 2 * s->mb_x + (n & 1); |
| 1589 |
y = 2 * s->mb_y + (n>> 1); |
| 1590 |
wrap = s->b8_stride; |
| 1591 |
dc_val = s->dc_val[0];
|
| 1592 |
ac_val = s->ac_val[0][0]; |
| 1593 |
scale = s->y_dc_scale; |
| 1594 |
} else {
|
| 1595 |
x = s->mb_x; |
| 1596 |
y = s->mb_y; |
| 1597 |
wrap = s->mb_stride; |
| 1598 |
dc_val = s->dc_val[n - 4 + 1]; |
| 1599 |
ac_val = s->ac_val[n - 4 + 1][0]; |
| 1600 |
scale = s->c_dc_scale; |
| 1601 |
} |
| 1602 |
|
| 1603 |
ac_val += ((y) * wrap + (x)) * 16;
|
| 1604 |
ac_val1 = ac_val; |
| 1605 |
|
| 1606 |
/* B C
|
| 1607 |
* A X
|
| 1608 |
*/
|
| 1609 |
a = dc_val[(x - 1) + (y) * wrap];
|
| 1610 |
c = dc_val[(x) + (y - 1) * wrap];
|
| 1611 |
|
| 1612 |
/* No prediction outside GOB boundary */
|
| 1613 |
if(s->first_slice_line && n!=3){ |
| 1614 |
if(n!=2) c= 1024; |
| 1615 |
if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; |
| 1616 |
} |
| 1617 |
|
| 1618 |
if (s->ac_pred) {
|
| 1619 |
pred_dc = 1024;
|
| 1620 |
if (s->h263_aic_dir) {
|
| 1621 |
/* left prediction */
|
| 1622 |
if (a != 1024) { |
| 1623 |
ac_val -= 16;
|
| 1624 |
for(i=1;i<8;i++) { |
| 1625 |
block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
|
| 1626 |
} |
| 1627 |
pred_dc = a; |
| 1628 |
} |
| 1629 |
} else {
|
| 1630 |
/* top prediction */
|
| 1631 |
if (c != 1024) { |
| 1632 |
ac_val -= 16 * wrap;
|
| 1633 |
for(i=1;i<8;i++) { |
| 1634 |
block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
|
| 1635 |
} |
| 1636 |
pred_dc = c; |
| 1637 |
} |
| 1638 |
} |
| 1639 |
} else {
|
| 1640 |
/* just DC prediction */
|
| 1641 |
if (a != 1024 && c != 1024) |
| 1642 |
pred_dc = (a + c) >> 1;
|
| 1643 |
else if (a != 1024) |
| 1644 |
pred_dc = a; |
| 1645 |
else
|
| 1646 |
pred_dc = c; |
| 1647 |
} |
| 1648 |
|
| 1649 |
/* we assume pred is positive */
|
| 1650 |
block[0]=block[0]*scale + pred_dc; |
| 1651 |
|
| 1652 |
if (block[0] < 0) |
| 1653 |
block[0] = 0; |
| 1654 |
else
|
| 1655 |
block[0] |= 1; |
| 1656 |
|
| 1657 |
/* Update AC/DC tables */
|
| 1658 |
dc_val[(x) + (y) * wrap] = block[0];
|
| 1659 |
|
| 1660 |
/* left copy */
|
| 1661 |
for(i=1;i<8;i++) |
| 1662 |
ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
|
| 1663 |
/* top copy */
|
| 1664 |
for(i=1;i<8;i++) |
| 1665 |
ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
|
| 1666 |
} |
| 1667 |
|
| 1668 |
int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir, |
| 1669 |
int *px, int *py) |
| 1670 |
{
|
| 1671 |
int wrap;
|
| 1672 |
int16_t *A, *B, *C, (*mot_val)[2];
|
| 1673 |
static const int off[4]= {2, 1, 1, -1}; |
| 1674 |
|
| 1675 |
wrap = s->b8_stride; |
| 1676 |
mot_val = s->current_picture.motion_val[dir] + s->block_index[block]; |
| 1677 |
|
| 1678 |
A = mot_val[ - 1];
|
| 1679 |
/* special case for first (slice) line */
|
| 1680 |
if (s->first_slice_line && block<3) { |
| 1681 |
// we can't just change some MVs to simulate that as we need them for the B frames (and ME)
|
| 1682 |
// and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
|
| 1683 |
if(block==0){ //most common case |
| 1684 |
if(s->mb_x == s->resync_mb_x){ //rare |
| 1685 |
*px= *py = 0;
|
| 1686 |
}else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare |
| 1687 |
C = mot_val[off[block] - wrap]; |
| 1688 |
if(s->mb_x==0){ |
| 1689 |
*px = C[0];
|
| 1690 |
*py = C[1];
|
| 1691 |
}else{
|
| 1692 |
*px = mid_pred(A[0], 0, C[0]); |
| 1693 |
*py = mid_pred(A[1], 0, C[1]); |
| 1694 |
} |
| 1695 |
}else{
|
| 1696 |
*px = A[0];
|
| 1697 |
*py = A[1];
|
| 1698 |
} |
| 1699 |
}else if(block==1){ |
| 1700 |
if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare |
| 1701 |
C = mot_val[off[block] - wrap]; |
| 1702 |
*px = mid_pred(A[0], 0, C[0]); |
| 1703 |
*py = mid_pred(A[1], 0, C[1]); |
| 1704 |
}else{
|
| 1705 |
*px = A[0];
|
| 1706 |
*py = A[1];
|
| 1707 |
} |
| 1708 |
}else{ /* block==2*/ |
| 1709 |
B = mot_val[ - wrap]; |
| 1710 |
C = mot_val[off[block] - wrap]; |
| 1711 |
if(s->mb_x == s->resync_mb_x) //rare |
| 1712 |
A[0]=A[1]=0; |
| 1713 |
|
| 1714 |
*px = mid_pred(A[0], B[0], C[0]); |
| 1715 |
*py = mid_pred(A[1], B[1], C[1]); |
| 1716 |
} |
| 1717 |
} else {
|
| 1718 |
B = mot_val[ - wrap]; |
| 1719 |
C = mot_val[off[block] - wrap]; |
| 1720 |
*px = mid_pred(A[0], B[0], C[0]); |
| 1721 |
*py = mid_pred(A[1], B[1], C[1]); |
| 1722 |
} |
| 1723 |
return *mot_val;
|
| 1724 |
} |
| 1725 |
|
| 1726 |
#ifdef CONFIG_ENCODERS
|
| 1727 |
void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) |
| 1728 |
{
|
| 1729 |
int range, l, bit_size, sign, code, bits;
|
| 1730 |
|
| 1731 |
if (val == 0) { |
| 1732 |
/* zero vector */
|
| 1733 |
code = 0;
|
| 1734 |
put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); |
| 1735 |
} else {
|
| 1736 |
bit_size = f_code - 1;
|
| 1737 |
range = 1 << bit_size;
|
| 1738 |
/* modulo encoding */
|
| 1739 |
l= INT_BIT - 6 - bit_size;
|
| 1740 |
val = (val<<l)>>l; |
| 1741 |
sign = val>>31;
|
| 1742 |
val= (val^sign)-sign; |
| 1743 |
sign&=1;
|
| 1744 |
|
| 1745 |
val--; |
| 1746 |
code = (val >> bit_size) + 1;
|
| 1747 |
bits = val & (range - 1);
|
| 1748 |
|
| 1749 |
put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); |
| 1750 |
if (bit_size > 0) { |
| 1751 |
put_bits(&s->pb, bit_size, bits); |
| 1752 |
} |
| 1753 |
} |
| 1754 |
} |
| 1755 |
|
| 1756 |
/* Encode MV differences on H.263+ with Unrestricted MV mode */
|
| 1757 |
static void h263p_encode_umotion(MpegEncContext * s, int val) |
| 1758 |
{
|
| 1759 |
short sval = 0; |
| 1760 |
short i = 0; |
| 1761 |
short n_bits = 0; |
| 1762 |
short temp_val;
|
| 1763 |
int code = 0; |
| 1764 |
int tcode;
|
| 1765 |
|
| 1766 |
if ( val == 0) |
| 1767 |
put_bits(&s->pb, 1, 1); |
| 1768 |
else if (val == 1) |
| 1769 |
put_bits(&s->pb, 3, 0); |
| 1770 |
else if (val == -1) |
| 1771 |
put_bits(&s->pb, 3, 2); |
| 1772 |
else {
|
| 1773 |
|
| 1774 |
sval = ((val < 0) ? (short)(-val):(short)val); |
| 1775 |
temp_val = sval; |
| 1776 |
|
| 1777 |
while (temp_val != 0) { |
| 1778 |
temp_val = temp_val >> 1;
|
| 1779 |
n_bits++; |
| 1780 |
} |
| 1781 |
|
| 1782 |
i = n_bits - 1;
|
| 1783 |
while (i > 0) { |
| 1784 |
tcode = (sval & (1 << (i-1))) >> (i-1); |
| 1785 |
tcode = (tcode << 1) | 1; |
| 1786 |
code = (code << 2) | tcode;
|
| 1787 |
i--; |
| 1788 |
} |
| 1789 |
code = ((code << 1) | (val < 0)) << 1; |
| 1790 |
put_bits(&s->pb, (2*n_bits)+1, code); |
| 1791 |
//printf("\nVal = %d\tCode = %d", sval, code);
|
| 1792 |
} |
| 1793 |
} |
| 1794 |
|
| 1795 |
static void init_mv_penalty_and_fcode(MpegEncContext *s) |
| 1796 |
{
|
| 1797 |
int f_code;
|
| 1798 |
int mv;
|
| 1799 |
|
| 1800 |
if(mv_penalty==NULL) |
| 1801 |
mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); |
| 1802 |
|
| 1803 |
for(f_code=1; f_code<=MAX_FCODE; f_code++){ |
| 1804 |
for(mv=-MAX_MV; mv<=MAX_MV; mv++){
|
| 1805 |
int len;
|
| 1806 |
|
| 1807 |
if(mv==0) len= mvtab[0][1]; |
| 1808 |
else{
|
| 1809 |
int val, bit_size, range, code;
|
| 1810 |
|
| 1811 |
bit_size = f_code - 1;
|
| 1812 |
range = 1 << bit_size;
|
| 1813 |
|
| 1814 |
val=mv; |
| 1815 |
if (val < 0) |
| 1816 |
val = -val; |
| 1817 |
val--; |
| 1818 |
code = (val >> bit_size) + 1;
|
| 1819 |
if(code<33){ |
| 1820 |
len= mvtab[code][1] + 1 + bit_size; |
| 1821 |
}else{
|
| 1822 |
len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size; |
| 1823 |
} |
| 1824 |
} |
| 1825 |
|
| 1826 |
mv_penalty[f_code][mv+MAX_MV]= len; |
| 1827 |
} |
| 1828 |
} |
| 1829 |
|
| 1830 |
for(f_code=MAX_FCODE; f_code>0; f_code--){ |
| 1831 |
for(mv=-(16<<f_code); mv<(16<<f_code); mv++){ |
| 1832 |
fcode_tab[mv+MAX_MV]= f_code; |
| 1833 |
} |
| 1834 |
} |
| 1835 |
|
| 1836 |
for(mv=0; mv<MAX_MV*2+1; mv++){ |
| 1837 |
umv_fcode_tab[mv]= 1;
|
| 1838 |
} |
| 1839 |
} |
| 1840 |
#endif
|
| 1841 |
|
| 1842 |
#ifdef CONFIG_ENCODERS
|
| 1843 |
|
| 1844 |
static void init_uni_dc_tab(void) |
| 1845 |
{
|
| 1846 |
int level, uni_code, uni_len;
|
| 1847 |
|
| 1848 |
for(level=-256; level<256; level++){ |
| 1849 |
int size, v, l;
|
| 1850 |
/* find number of bits */
|
| 1851 |
size = 0;
|
| 1852 |
v = abs(level); |
| 1853 |
while (v) {
|
| 1854 |
v >>= 1;
|
| 1855 |
size++; |
| 1856 |
} |
| 1857 |
|
| 1858 |
if (level < 0) |
| 1859 |
l= (-level) ^ ((1 << size) - 1); |
| 1860 |
else
|
| 1861 |
l= level; |
| 1862 |
|
| 1863 |
/* luminance */
|
| 1864 |
uni_code= DCtab_lum[size][0];
|
| 1865 |
uni_len = DCtab_lum[size][1];
|
| 1866 |
|
| 1867 |
if (size > 0) { |
| 1868 |
uni_code<<=size; uni_code|=l; |
| 1869 |
uni_len+=size; |
| 1870 |
if (size > 8){ |
| 1871 |
uni_code<<=1; uni_code|=1; |
| 1872 |
uni_len++; |
| 1873 |
} |
| 1874 |
} |
| 1875 |
uni_DCtab_lum_bits[level+256]= uni_code;
|
| 1876 |
uni_DCtab_lum_len [level+256]= uni_len;
|
| 1877 |
|
| 1878 |
/* chrominance */
|
| 1879 |
uni_code= DCtab_chrom[size][0];
|
| 1880 |
uni_len = DCtab_chrom[size][1];
|
| 1881 |
|
| 1882 |
if (size > 0) { |
| 1883 |
uni_code<<=size; uni_code|=l; |
| 1884 |
uni_len+=size; |
| 1885 |
if (size > 8){ |
| 1886 |
uni_code<<=1; uni_code|=1; |
| 1887 |
uni_len++; |
| 1888 |
} |
| 1889 |
} |
| 1890 |
uni_DCtab_chrom_bits[level+256]= uni_code;
|
| 1891 |
uni_DCtab_chrom_len [level+256]= uni_len;
|
| 1892 |
|
| 1893 |
} |
| 1894 |
} |
| 1895 |
|
| 1896 |
#endif //CONFIG_ENCODERS |
| 1897 |
|
| 1898 |
#ifdef CONFIG_ENCODERS
|
| 1899 |
static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
| 1900 |
int slevel, run, last;
|
| 1901 |
|
| 1902 |
assert(MAX_LEVEL >= 64);
|
| 1903 |
assert(MAX_RUN >= 63);
|
| 1904 |
|
| 1905 |
for(slevel=-64; slevel<64; slevel++){ |
| 1906 |
if(slevel==0) continue; |
| 1907 |
for(run=0; run<64; run++){ |
| 1908 |
for(last=0; last<=1; last++){ |
| 1909 |
const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); |
| 1910 |
int level= slevel < 0 ? -slevel : slevel; |
| 1911 |
int sign= slevel < 0 ? 1 : 0; |
| 1912 |
int bits, len, code;
|
| 1913 |
int level1, run1;
|
| 1914 |
|
| 1915 |
len_tab[index]= 100;
|
| 1916 |
|
| 1917 |
/* ESC0 */
|
| 1918 |
code= get_rl_index(rl, last, run, level); |
| 1919 |
bits= rl->table_vlc[code][0];
|
| 1920 |
len= rl->table_vlc[code][1];
|
| 1921 |
bits=bits*2+sign; len++;
|
| 1922 |
|
| 1923 |
if(code!=rl->n && len < len_tab[index]){
|
| 1924 |
bits_tab[index]= bits; |
| 1925 |
len_tab [index]= len; |
| 1926 |
} |
| 1927 |
#if 1 |
| 1928 |
/* ESC1 */
|
| 1929 |
bits= rl->table_vlc[rl->n][0];
|
| 1930 |
len= rl->table_vlc[rl->n][1];
|
| 1931 |
bits=bits*2; len++; //esc1 |
| 1932 |
level1= level - rl->max_level[last][run]; |
| 1933 |
if(level1>0){ |
| 1934 |
code= get_rl_index(rl, last, run, level1); |
| 1935 |
bits<<= rl->table_vlc[code][1];
|
| 1936 |
len += rl->table_vlc[code][1];
|
| 1937 |
bits += rl->table_vlc[code][0];
|
| 1938 |
bits=bits*2+sign; len++;
|
| 1939 |
|
| 1940 |
if(code!=rl->n && len < len_tab[index]){
|
| 1941 |
bits_tab[index]= bits; |
| 1942 |
len_tab [index]= len; |
| 1943 |
} |
| 1944 |
} |
| 1945 |
#endif
|
| 1946 |
#if 1 |
| 1947 |
/* ESC2 */
|
| 1948 |
bits= rl->table_vlc[rl->n][0];
|
| 1949 |
len= rl->table_vlc[rl->n][1];
|
| 1950 |
bits=bits*4+2; len+=2; //esc2 |
| 1951 |
run1 = run - rl->max_run[last][level] - 1;
|
| 1952 |
if(run1>=0){ |
| 1953 |
code= get_rl_index(rl, last, run1, level); |
| 1954 |
bits<<= rl->table_vlc[code][1];
|
| 1955 |
len += rl->table_vlc[code][1];
|
| 1956 |
bits += rl->table_vlc[code][0];
|
| 1957 |
bits=bits*2+sign; len++;
|
| 1958 |
|
| 1959 |
if(code!=rl->n && len < len_tab[index]){
|
| 1960 |
bits_tab[index]= bits; |
| 1961 |
len_tab [index]= len; |
| 1962 |
} |
| 1963 |
} |
| 1964 |
#endif
|
| 1965 |
/* ESC3 */
|
| 1966 |
bits= rl->table_vlc[rl->n][0];
|
| 1967 |
len = rl->table_vlc[rl->n][1];
|
| 1968 |
bits=bits*4+3; len+=2; //esc3 |
| 1969 |
bits=bits*2+last; len++;
|
| 1970 |
bits=bits*64+run; len+=6; |
| 1971 |
bits=bits*2+1; len++; //marker |
| 1972 |
bits=bits*4096+(slevel&0xfff); len+=12; |
| 1973 |
bits=bits*2+1; len++; //marker |
| 1974 |
|
| 1975 |
if(len < len_tab[index]){
|
| 1976 |
bits_tab[index]= bits; |
| 1977 |
len_tab [index]= len; |
| 1978 |
} |
| 1979 |
} |
| 1980 |
} |
| 1981 |
} |
| 1982 |
} |
| 1983 |
|
| 1984 |
static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
| 1985 |
int slevel, run, last;
|
| 1986 |
|
| 1987 |
assert(MAX_LEVEL >= 64);
|
| 1988 |
assert(MAX_RUN >= 63);
|
| 1989 |
|
| 1990 |
for(slevel=-64; slevel<64; slevel++){ |
| 1991 |
if(slevel==0) continue; |
| 1992 |
for(run=0; run<64; run++){ |
| 1993 |
for(last=0; last<=1; last++){ |
| 1994 |
const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); |
| 1995 |
int level= slevel < 0 ? -slevel : slevel; |
| 1996 |
int sign= slevel < 0 ? 1 : 0; |
| 1997 |
int bits, len, code;
|
| 1998 |
|
| 1999 |
len_tab[index]= 100;
|
| 2000 |
|
| 2001 |
/* ESC0 */
|
| 2002 |
code= get_rl_index(rl, last, run, level); |
| 2003 |
bits= rl->table_vlc[code][0];
|
| 2004 |
len= rl->table_vlc[code][1];
|
| 2005 |
bits=bits*2+sign; len++;
|
| 2006 |
|
| 2007 |
if(code!=rl->n && len < len_tab[index]){
|
| 2008 |
if(bits_tab) bits_tab[index]= bits;
|
| 2009 |
len_tab [index]= len; |
| 2010 |
} |
| 2011 |
/* ESC */
|
| 2012 |
bits= rl->table_vlc[rl->n][0];
|
| 2013 |
len = rl->table_vlc[rl->n][1];
|
| 2014 |
bits=bits*2+last; len++;
|
| 2015 |
bits=bits*64+run; len+=6; |
| 2016 |
bits=bits*256+(level&0xff); len+=8; |
| 2017 |
|
| 2018 |
if(len < len_tab[index]){
|
| 2019 |
if(bits_tab) bits_tab[index]= bits;
|
| 2020 |
len_tab [index]= len; |
| 2021 |
} |
| 2022 |
} |
| 2023 |
} |
| 2024 |
} |
| 2025 |
} |
| 2026 |
|
| 2027 |
void h263_encode_init(MpegEncContext *s)
|
| 2028 |
{
|
| 2029 |
static int done = 0; |
| 2030 |
|
| 2031 |
if (!done) {
|
| 2032 |
done = 1;
|
| 2033 |
|
| 2034 |
init_uni_dc_tab(); |
| 2035 |
|
| 2036 |
init_rl(&rl_inter, 1);
|
| 2037 |
init_rl(&rl_intra, 1);
|
| 2038 |
init_rl(&rl_intra_aic, 1);
|
| 2039 |
|
| 2040 |
init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len); |
| 2041 |
init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len); |
| 2042 |
|
| 2043 |
init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
|
| 2044 |
init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
|
| 2045 |
|
| 2046 |
init_mv_penalty_and_fcode(s); |
| 2047 |
} |
| 2048 |
s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
|
| 2049 |
|
| 2050 |
s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len; |
| 2051 |
s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; |
| 2052 |
if(s->h263_aic){
|
| 2053 |
s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len; |
| 2054 |
s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; |
| 2055 |
} |
| 2056 |
s->ac_esc_length= 7+1+6+8; |
| 2057 |
|
| 2058 |
// use fcodes >1 only for mpeg4 & h263 & h263p FIXME
|
| 2059 |
switch(s->codec_id){
|
| 2060 |
case CODEC_ID_MPEG4:
|
| 2061 |
s->fcode_tab= fcode_tab; |
| 2062 |
s->min_qcoeff= -2048;
|
| 2063 |
s->max_qcoeff= 2047;
|
| 2064 |
s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
| 2065 |
s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; |
| 2066 |
s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; |
| 2067 |
s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; |
| 2068 |
s->luma_dc_vlc_length= uni_DCtab_lum_len; |
| 2069 |
s->chroma_dc_vlc_length= uni_DCtab_chrom_len; |
| 2070 |
s->ac_esc_length= 7+2+1+6+1+12+1; |
| 2071 |
s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; |
| 2072 |
s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; |
| 2073 |
|
| 2074 |
if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
|
| 2075 |
|
| 2076 |
s->avctx->extradata= av_malloc(1024);
|
| 2077 |
init_put_bits(&s->pb, s->avctx->extradata, 1024);
|
| 2078 |
|
| 2079 |
if(!(s->workaround_bugs & FF_BUG_MS))
|
| 2080 |
mpeg4_encode_visual_object_header(s); |
| 2081 |
mpeg4_encode_vol_header(s, 0, 0); |
| 2082 |
|
| 2083 |
// ff_mpeg4_stuffing(&s->pb); ?
|
| 2084 |
flush_put_bits(&s->pb); |
| 2085 |
s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3; |
| 2086 |
} |
| 2087 |
|
| 2088 |
break;
|
| 2089 |
case CODEC_ID_H263P:
|
| 2090 |
if(s->umvplus)
|
| 2091 |
s->fcode_tab= umv_fcode_tab; |
| 2092 |
if(s->modified_quant){
|
| 2093 |
s->min_qcoeff= -2047;
|
| 2094 |
s->max_qcoeff= 2047;
|
| 2095 |
}else{
|
| 2096 |
s->min_qcoeff= -127;
|
| 2097 |
s->max_qcoeff= 127;
|
| 2098 |
} |
| 2099 |
break;
|
| 2100 |
//Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
|
| 2101 |
case CODEC_ID_FLV1:
|
| 2102 |
if (s->h263_flv > 1) { |
| 2103 |
s->min_qcoeff= -1023;
|
| 2104 |
s->max_qcoeff= 1023;
|
| 2105 |
} else {
|
| 2106 |
s->min_qcoeff= -127;
|
| 2107 |
s->max_qcoeff= 127;
|
| 2108 |
} |
| 2109 |
s->y_dc_scale_table= |
| 2110 |
s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
| 2111 |
break;
|
| 2112 |
default: //nothing needed - default table already set in mpegvideo.c |
| 2113 |
s->min_qcoeff= -127;
|
| 2114 |
s->max_qcoeff= 127;
|
| 2115 |
s->y_dc_scale_table= |
| 2116 |
s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
| 2117 |
} |
| 2118 |
} |
| 2119 |
|
| 2120 |
/**
|
| 2121 |
* encodes a 8x8 block.
|
| 2122 |
* @param block the 8x8 block
|
| 2123 |
* @param n block index (0-3 are luma, 4-5 are chroma)
|
| 2124 |
*/
|
| 2125 |
static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
| 2126 |
{
|
| 2127 |
int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
|
| 2128 |
RLTable *rl; |
| 2129 |
|
| 2130 |
rl = &rl_inter; |
| 2131 |
if (s->mb_intra && !s->h263_aic) {
|
| 2132 |
/* DC coef */
|
| 2133 |
level = block[0];
|
| 2134 |
/* 255 cannot be represented, so we clamp */
|
| 2135 |
if (level > 254) { |
| 2136 |
level = 254;
|
| 2137 |
block[0] = 254; |
| 2138 |
} |
| 2139 |
/* 0 cannot be represented also */
|
| 2140 |
else if (level < 1) { |
| 2141 |
level = 1;
|
| 2142 |
block[0] = 1; |
| 2143 |
} |
| 2144 |
if (level == 128) //FIXME check rv10 |
| 2145 |
put_bits(&s->pb, 8, 0xff); |
| 2146 |
else
|
| 2147 |
put_bits(&s->pb, 8, level);
|
| 2148 |
i = 1;
|
| 2149 |
} else {
|
| 2150 |
i = 0;
|
| 2151 |
if (s->h263_aic && s->mb_intra)
|
| 2152 |
rl = &rl_intra_aic; |
| 2153 |
|
| 2154 |
if(s->alt_inter_vlc && !s->mb_intra){
|
| 2155 |
int aic_vlc_bits=0; |
| 2156 |
int inter_vlc_bits=0; |
| 2157 |
int wrong_pos=-1; |
| 2158 |
int aic_code;
|
| 2159 |
|
| 2160 |
last_index = s->block_last_index[n]; |
| 2161 |
last_non_zero = i - 1;
|
| 2162 |
for (; i <= last_index; i++) {
|
| 2163 |
j = s->intra_scantable.permutated[i]; |
| 2164 |
level = block[j]; |
| 2165 |
if (level) {
|
| 2166 |
run = i - last_non_zero - 1;
|
| 2167 |
last = (i == last_index); |
| 2168 |
|
| 2169 |
if(level<0) level= -level; |
| 2170 |
|
| 2171 |
code = get_rl_index(rl, last, run, level); |
| 2172 |
aic_code = get_rl_index(&rl_intra_aic, last, run, level); |
| 2173 |
inter_vlc_bits += rl->table_vlc[code][1]+1; |
| 2174 |
aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; |
| 2175 |
|
| 2176 |
if (code == rl->n) {
|
| 2177 |
inter_vlc_bits += 1+6+8-1; |
| 2178 |
} |
| 2179 |
if (aic_code == rl_intra_aic.n) {
|
| 2180 |
aic_vlc_bits += 1+6+8-1; |
| 2181 |
wrong_pos += run + 1;
|
| 2182 |
}else
|
| 2183 |
wrong_pos += wrong_run[aic_code]; |
| 2184 |
last_non_zero = i; |
| 2185 |
} |
| 2186 |
} |
| 2187 |
i = 0;
|
| 2188 |
if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) |
| 2189 |
rl = &rl_intra_aic; |
| 2190 |
} |
| 2191 |
} |
| 2192 |
|
| 2193 |
/* AC coefs */
|
| 2194 |
last_index = s->block_last_index[n]; |
| 2195 |
last_non_zero = i - 1;
|
| 2196 |
for (; i <= last_index; i++) {
|
| 2197 |
j = s->intra_scantable.permutated[i]; |
| 2198 |
level = block[j]; |
| 2199 |
if (level) {
|
| 2200 |
run = i - last_non_zero - 1;
|
| 2201 |
last = (i == last_index); |
| 2202 |
sign = 0;
|
| 2203 |
slevel = level; |
| 2204 |
if (level < 0) { |
| 2205 |
sign = 1;
|
| 2206 |
level = -level; |
| 2207 |
} |
| 2208 |
code = get_rl_index(rl, last, run, level); |
| 2209 |
put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
| 2210 |
if (code == rl->n) {
|
| 2211 |
if(s->h263_flv <= 1){ |
| 2212 |
put_bits(&s->pb, 1, last);
|
| 2213 |
put_bits(&s->pb, 6, run);
|
| 2214 |
|
| 2215 |
assert(slevel != 0);
|
| 2216 |
|
| 2217 |
if(level < 128) |
| 2218 |
put_bits(&s->pb, 8, slevel & 0xff); |
| 2219 |
else{
|
| 2220 |
put_bits(&s->pb, 8, 128); |
| 2221 |
put_bits(&s->pb, 5, slevel & 0x1f); |
| 2222 |
put_bits(&s->pb, 6, (slevel>>5)&0x3f); |
| 2223 |
} |
| 2224 |
}else{
|
| 2225 |
if(level < 64) { // 7-bit level |
| 2226 |
put_bits(&s->pb, 1, 0); |
| 2227 |
put_bits(&s->pb, 1, last);
|
| 2228 |
put_bits(&s->pb, 6, run);
|
| 2229 |
|
| 2230 |
put_bits(&s->pb, 7, slevel & 0x7f); |
| 2231 |
} else {
|
| 2232 |
/* 11-bit level */
|
| 2233 |
put_bits(&s->pb, 1, 1); |
| 2234 |
put_bits(&s->pb, 1, last);
|
| 2235 |
put_bits(&s->pb, 6, run);
|
| 2236 |
|
| 2237 |
put_bits(&s->pb, 11, slevel & 0x7ff); |
| 2238 |
} |
| 2239 |
} |
| 2240 |
} else {
|
| 2241 |
put_bits(&s->pb, 1, sign);
|
| 2242 |
} |
| 2243 |
last_non_zero = i; |
| 2244 |
} |
| 2245 |
} |
| 2246 |
} |
| 2247 |
#endif
|
| 2248 |
|
| 2249 |
#ifdef CONFIG_ENCODERS
|
| 2250 |
|
| 2251 |
/***************************************************/
|
| 2252 |
/**
|
| 2253 |
* add mpeg4 stuffing bits (01...1)
|
| 2254 |
*/
|
| 2255 |
void ff_mpeg4_stuffing(PutBitContext * pbc)
|
| 2256 |
{
|
| 2257 |
int length;
|
| 2258 |
put_bits(pbc, 1, 0); |
| 2259 |
length= (-put_bits_count(pbc))&7;
|
| 2260 |
if(length) put_bits(pbc, length, (1<<length)-1); |
| 2261 |
} |
| 2262 |
|
| 2263 |
/* must be called before writing the header */
|
| 2264 |
void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ |
| 2265 |
int time_div, time_mod;
|
| 2266 |
|
| 2267 |
assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE); |
| 2268 |
s->time= s->current_picture_ptr->pts*s->avctx->time_base.num; |
| 2269 |
|
| 2270 |
time_div= s->time/s->avctx->time_base.den; |
| 2271 |
time_mod= s->time%s->avctx->time_base.den; |
| 2272 |
|
| 2273 |
if(s->pict_type==B_TYPE){
|
| 2274 |
s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
| 2275 |
assert(s->pb_time > 0 && s->pb_time < s->pp_time);
|
| 2276 |
ff_mpeg4_init_direct_mv(s); |
| 2277 |
}else{
|
| 2278 |
s->last_time_base= s->time_base; |
| 2279 |
s->time_base= time_div; |
| 2280 |
s->pp_time= s->time - s->last_non_b_time; |
| 2281 |
s->last_non_b_time= s->time; |
| 2282 |
assert(picture_number==0 || s->pp_time > 0); |
| 2283 |
} |
| 2284 |
} |
| 2285 |
|
| 2286 |
static void mpeg4_encode_gop_header(MpegEncContext * s){ |
| 2287 |
int hours, minutes, seconds;
|
| 2288 |
int64_t time; |
| 2289 |
|
| 2290 |
put_bits(&s->pb, 16, 0); |
| 2291 |
put_bits(&s->pb, 16, GOP_STARTCODE);
|
| 2292 |
|
| 2293 |
time= s->current_picture_ptr->pts; |
| 2294 |
if(s->reordered_input_picture[1]) |
| 2295 |
time= FFMIN(time, s->reordered_input_picture[1]->pts);
|
| 2296 |
time= time*s->avctx->time_base.num; |
| 2297 |
|
| 2298 |
seconds= time/s->avctx->time_base.den; |
| 2299 |
minutes= seconds/60; seconds %= 60; |
| 2300 |
hours= minutes/60; minutes %= 60; |
| 2301 |
hours%=24;
|
| 2302 |
|
| 2303 |
put_bits(&s->pb, 5, hours);
|
| 2304 |
put_bits(&s->pb, 6, minutes);
|
| 2305 |
put_bits(&s->pb, 1, 1); |
| 2306 |
put_bits(&s->pb, 6, seconds);
|
| 2307 |
|
| 2308 |
put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
|
| 2309 |
put_bits(&s->pb, 1, 0); //broken link == NO |
| 2310 |
|
| 2311 |
s->last_time_base= time / s->avctx->time_base.den; |
| 2312 |
|
| 2313 |
ff_mpeg4_stuffing(&s->pb); |
| 2314 |
} |
| 2315 |
|
| 2316 |
static void mpeg4_encode_visual_object_header(MpegEncContext * s){ |
| 2317 |
int profile_and_level_indication;
|
| 2318 |
int vo_ver_id;
|
| 2319 |
|
| 2320 |
if(s->avctx->profile != FF_PROFILE_UNKNOWN){
|
| 2321 |
profile_and_level_indication = s->avctx->profile << 4;
|
| 2322 |
}else if(s->max_b_frames || s->quarter_sample){ |
| 2323 |
profile_and_level_indication= 0xF0; // adv simple |
| 2324 |
}else{
|
| 2325 |
profile_and_level_indication= 0x00; // simple |
| 2326 |
} |
| 2327 |
|
| 2328 |
if(s->avctx->level != FF_LEVEL_UNKNOWN){
|
| 2329 |
profile_and_level_indication |= s->avctx->level; |
| 2330 |
}else{
|
| 2331 |
profile_and_level_indication |= 1; //level 1 |
| 2332 |
} |
| 2333 |
|
| 2334 |
if(profile_and_level_indication>>4 == 0xF){ |
| 2335 |
vo_ver_id= 5;
|
| 2336 |
}else{
|
| 2337 |
vo_ver_id= 1;
|
| 2338 |
} |
| 2339 |
|
| 2340 |
//FIXME levels
|
| 2341 |
|
| 2342 |
put_bits(&s->pb, 16, 0); |
| 2343 |
put_bits(&s->pb, 16, VOS_STARTCODE);
|
| 2344 |
|
| 2345 |
put_bits(&s->pb, 8, profile_and_level_indication);
|
| 2346 |
|
| 2347 |
put_bits(&s->pb, 16, 0); |
| 2348 |
put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
|
| 2349 |
|
| 2350 |
put_bits(&s->pb, 1, 1); |
| 2351 |
put_bits(&s->pb, 4, vo_ver_id);
|
| 2352 |
put_bits(&s->pb, 3, 1); //priority |
| 2353 |
|
| 2354 |
put_bits(&s->pb, 4, 1); //visual obj type== video obj |
| 2355 |
|
| 2356 |
put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME |
| 2357 |
|
| 2358 |
ff_mpeg4_stuffing(&s->pb); |
| 2359 |
} |
| 2360 |
|
| 2361 |
static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) |
| 2362 |
{
|
| 2363 |
int vo_ver_id;
|
| 2364 |
|
| 2365 |
if(s->max_b_frames || s->quarter_sample){
|
| 2366 |
vo_ver_id= 5;
|
| 2367 |
s->vo_type= ADV_SIMPLE_VO_TYPE; |
| 2368 |
}else{
|
| 2369 |
vo_ver_id= 1;
|
| 2370 |
s->vo_type= SIMPLE_VO_TYPE; |
| 2371 |
} |
| 2372 |
|
| 2373 |
put_bits(&s->pb, 16, 0); |
| 2374 |
put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
| 2375 |
put_bits(&s->pb, 16, 0); |
| 2376 |
put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
| 2377 |
|
| 2378 |
put_bits(&s->pb, 1, 0); /* random access vol */ |
| 2379 |
put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ |
| 2380 |
if(s->workaround_bugs & FF_BUG_MS) {
|
| 2381 |
put_bits(&s->pb, 1, 0); /* is obj layer id= no */ |
| 2382 |
} else {
|
| 2383 |
put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
| 2384 |
put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ |
| 2385 |
put_bits(&s->pb, 3, 1); /* is obj layer priority */ |
| 2386 |
} |
| 2387 |
|
| 2388 |
aspect_to_info(s, s->avctx->sample_aspect_ratio); |
| 2389 |
|
| 2390 |
put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ |
| 2391 |
if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
|
| 2392 |
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
|
| 2393 |
put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
|
| 2394 |
} |
| 2395 |
|
| 2396 |
if(s->workaround_bugs & FF_BUG_MS) { // |
| 2397 |
put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */ |
| 2398 |
} else {
|
| 2399 |
put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ |
| 2400 |
put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ |
| 2401 |
put_bits(&s->pb, 1, s->low_delay);
|
| 2402 |
put_bits(&s->pb, 1, 0); /* vbv parameters= no */ |
| 2403 |
} |
| 2404 |
|
| 2405 |
put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ |
| 2406 |
put_bits(&s->pb, 1, 1); /* marker bit */ |
| 2407 |
|
| 2408 |
put_bits(&s->pb, 16, s->avctx->time_base.den);
|
| 2409 |
if (s->time_increment_bits < 1) |
| 2410 |
s->time_increment_bits = 1;
|
| 2411 |
put_bits(&s->pb, 1, 1); /* marker bit */ |
| 2412 |
put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ |
| 2413 |
put_bits(&s->pb, 1, 1); /* marker bit */ |
| 2414 |
put_bits(&s->pb, 13, s->width); /* vol width */ |
| 2415 |
put_bits(&s->pb, 1, 1); /* marker bit */ |
| 2416 |
put_bits(&s->pb, 13, s->height); /* vol height */ |
| 2417 |
put_bits(&s->pb, 1, 1); /* marker bit */ |
| 2418 |
put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
| 2419 |
put_bits(&s->pb, 1, 1); /* obmc disable */ |
| 2420 |
if (vo_ver_id == 1) { |
| 2421 |
put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ |
| 2422 |
}else{
|
| 2423 |
put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ |
| 2424 |
} |
| 2425 |
|
| 2426 |
put_bits(&s->pb, 1, 0); /* not 8 bit == false */ |
| 2427 |
put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ |
| 2428 |
|
| 2429 |
if(s->mpeg_quant){
|
| 2430 |
ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); |
| 2431 |
ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); |
| 2432 |
} |
| 2433 |
|
| 2434 |
if (vo_ver_id != 1) |
| 2435 |
put_bits(&s->pb, 1, s->quarter_sample);
|
| 2436 |
put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
| 2437 |
s->resync_marker= s->rtp_mode; |
| 2438 |
put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ |
| 2439 |
put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); |
| 2440 |
if(s->data_partitioning){
|
| 2441 |
put_bits(&s->pb, 1, 0); /* no rvlc */ |
| 2442 |
} |
| 2443 |
|
| 2444 |
if (vo_ver_id != 1){ |
| 2445 |
put_bits(&s->pb, 1, 0); /* newpred */ |
| 2446 |
put_bits(&s->pb, 1, 0); /* reduced res vop */ |
| 2447 |
} |
| 2448 |
put_bits(&s->pb, 1, 0); /* scalability */ |
| 2449 |
|
| 2450 |
ff_mpeg4_stuffing(&s->pb); |
| 2451 |
|
| 2452 |
/* user data */
|
| 2453 |
if(!(s->flags & CODEC_FLAG_BITEXACT)){
|
| 2454 |
put_bits(&s->pb, 16, 0); |
| 2455 |
put_bits(&s->pb, 16, 0x1B2); /* user_data */ |
| 2456 |
ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
|
| 2457 |
} |
| 2458 |
} |
| 2459 |
|
| 2460 |
/* write mpeg4 VOP header */
|
| 2461 |
void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) |
| 2462 |
{
|
| 2463 |
int time_incr;
|
| 2464 |
int time_div, time_mod;
|
| 2465 |
|
| 2466 |
if(s->pict_type==I_TYPE){
|
| 2467 |
if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
|
| 2468 |
if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy |
| 2469 |
mpeg4_encode_visual_object_header(s); |
| 2470 |
if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy |
| 2471 |
mpeg4_encode_vol_header(s, 0, 0); |
| 2472 |
} |
| 2473 |
if(!(s->workaround_bugs & FF_BUG_MS))
|
| 2474 |
mpeg4_encode_gop_header(s); |
| 2475 |
} |
| 2476 |
|
| 2477 |
s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; |
| 2478 |
|
| 2479 |
//printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE);
|
| 2480 |
|
| 2481 |
put_bits(&s->pb, 16, 0); /* vop header */ |
| 2482 |
put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ |
| 2483 |
put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
| 2484 |
|
| 2485 |
assert(s->time>=0);
|
| 2486 |
time_div= s->time/s->avctx->time_base.den; |
| 2487 |
time_mod= s->time%s->avctx->time_base.den; |
| 2488 |
time_incr= time_div - s->last_time_base; |
| 2489 |
assert(time_incr >= 0);
|
| 2490 |
while(time_incr--)
|
| 2491 |
put_bits(&s->pb, 1, 1); |
| 2492 |
|
| 2493 |
put_bits(&s->pb, 1, 0); |
| 2494 |
|
| 2495 |
put_bits(&s->pb, 1, 1); /* marker */ |
| 2496 |
put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
|
| 2497 |
put_bits(&s->pb, 1, 1); /* marker */ |
| 2498 |
put_bits(&s->pb, 1, 1); /* vop coded */ |
| 2499 |
if ( s->pict_type == P_TYPE
|
| 2500 |
|| (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
|
| 2501 |
put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
| 2502 |
} |
| 2503 |
put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ |
| 2504 |
if(!s->progressive_sequence){
|
| 2505 |
put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
|
| 2506 |
put_bits(&s->pb, 1, s->alternate_scan);
|
| 2507 |
} |
| 2508 |
//FIXME sprite stuff
|
| 2509 |
|
| 2510 |
put_bits(&s->pb, 5, s->qscale);
|
| 2511 |
|
| 2512 |
if (s->pict_type != I_TYPE)
|
| 2513 |
put_bits(&s->pb, 3, s->f_code); /* fcode_for */ |
| 2514 |
if (s->pict_type == B_TYPE)
|
| 2515 |
put_bits(&s->pb, 3, s->b_code); /* fcode_back */ |
| 2516 |
// printf("****frame %d\n", picture_number);
|
| 2517 |
} |
| 2518 |
|
| 2519 |
#endif //CONFIG_ENCODERS |
| 2520 |
|
| 2521 |
/**
|
| 2522 |
* set qscale and update qscale dependent variables.
|
| 2523 |
*/
|
| 2524 |
void ff_set_qscale(MpegEncContext * s, int qscale) |
| 2525 |
{
|
| 2526 |
if (qscale < 1) |
| 2527 |
qscale = 1;
|
| 2528 |
else if (qscale > 31) |
| 2529 |
qscale = 31;
|
| 2530 |
|
| 2531 |
s->qscale = qscale; |
| 2532 |
s->chroma_qscale= s->chroma_qscale_table[qscale]; |
| 2533 |
|
| 2534 |
s->y_dc_scale= s->y_dc_scale_table[ qscale ]; |
| 2535 |
s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ]; |
| 2536 |
} |
| 2537 |
|
| 2538 |
/**
|
| 2539 |
* predicts the dc.
|
| 2540 |
* encoding quantized level -> quantized diff
|
| 2541 |
* decoding quantized diff -> quantized level
|
| 2542 |
* @param n block index (0-3 are luma, 4-5 are chroma)
|
| 2543 |
* @param dir_ptr pointer to an integer where the prediction direction will be stored
|
| 2544 |
*/
|
| 2545 |
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) |
| 2546 |
{
|
| 2547 |
int a, b, c, wrap, pred, scale, ret;
|
| 2548 |
int16_t *dc_val; |
| 2549 |
|
| 2550 |
/* find prediction */
|
| 2551 |
if (n < 4) { |
| 2552 |
scale = s->y_dc_scale; |
| 2553 |
} else {
|
| 2554 |
scale = s->c_dc_scale; |
| 2555 |
} |
| 2556 |
if(IS_3IV1)
|
| 2557 |
scale= 8;
|
| 2558 |
|
| 2559 |
wrap= s->block_wrap[n]; |
| 2560 |
dc_val = s->dc_val[0] + s->block_index[n];
|
| 2561 |
|
| 2562 |
/* B C
|
| 2563 |
* A X
|
| 2564 |
*/
|
| 2565 |
a = dc_val[ - 1];
|
| 2566 |
b = dc_val[ - 1 - wrap];
|
| 2567 |
c = dc_val[ - wrap]; |
| 2568 |
|
| 2569 |
/* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
|
| 2570 |
if(s->first_slice_line && n!=3){ |
| 2571 |
if(n!=2) b=c= 1024; |
| 2572 |
if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024; |
| 2573 |
} |
| 2574 |
if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){ |
| 2575 |
if(n==0 || n==4 || n==5) |
| 2576 |
b=1024;
|
| 2577 |
} |
| 2578 |
|
| 2579 |
if (abs(a - b) < abs(b - c)) {
|
| 2580 |
pred = c; |
| 2581 |
*dir_ptr = 1; /* top */ |
| 2582 |
} else {
|
| 2583 |
pred = a; |
| 2584 |
*dir_ptr = 0; /* left */ |
| 2585 |
} |
| 2586 |
/* we assume pred is positive */
|
| 2587 |
pred = FASTDIV((pred + (scale >> 1)), scale);
|
| 2588 |
|
| 2589 |
if(encoding){
|
| 2590 |
ret = level - pred; |
| 2591 |
}else{
|
| 2592 |
level += pred; |
| 2593 |
ret= level; |
| 2594 |
if(s->error_resilience>=3){ |
| 2595 |
if(level<0){ |
| 2596 |
av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
|
| 2597 |
return -1; |
| 2598 |
} |
| 2599 |
if(level*scale > 2048 + scale){ |
| 2600 |
av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
|
| 2601 |
return -1; |
| 2602 |
} |
| 2603 |
} |
| 2604 |
} |
| 2605 |
level *=scale; |
| 2606 |
if(level&(~2047)){ |
| 2607 |
if(level<0) |
| 2608 |
level=0;
|
| 2609 |
else if(!(s->workaround_bugs&FF_BUG_DC_CLIP)) |
| 2610 |
level=2047;
|
| 2611 |
} |
| 2612 |
dc_val[0]= level;
|
| 2613 |
|
| 2614 |
return ret;
|
| 2615 |
} |
| 2616 |
|
| 2617 |
/**
|
| 2618 |
* predicts the ac.
|
| 2619 |
* @param n block index (0-3 are luma, 4-5 are chroma)
|
| 2620 |
* @param dir the ac prediction direction
|
| 2621 |
*/
|
| 2622 |
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
| 2623 |
int dir)
|
| 2624 |
{
|
| 2625 |
int i;
|
| 2626 |
int16_t *ac_val, *ac_val1; |
| 2627 |
int8_t * const qscale_table= s->current_picture.qscale_table;
|
| 2628 |
|
| 2629 |
/* find prediction */
|
| 2630 |
ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
| 2631 |
ac_val1 = ac_val; |
| 2632 |
if (s->ac_pred) {
|
| 2633 |
if (dir == 0) { |
| 2634 |
const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
| 2635 |
/* left prediction */
|
| 2636 |
ac_val -= 16;
|
| 2637 |
|
| 2638 |
if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
| 2639 |
/* same qscale */
|
| 2640 |
for(i=1;i<8;i++) { |
| 2641 |
block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
|
| 2642 |
} |
| 2643 |
}else{
|
| 2644 |
/* different qscale, we must rescale */
|
| 2645 |
for(i=1;i<8;i++) { |
| 2646 |
block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
|
| 2647 |
} |
| 2648 |
} |
| 2649 |
} else {
|
| 2650 |
const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
| 2651 |
/* top prediction */
|
| 2652 |
ac_val -= 16 * s->block_wrap[n];
|
| 2653 |
|
| 2654 |
if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
| 2655 |
/* same qscale */
|
| 2656 |
for(i=1;i<8;i++) { |
| 2657 |
block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
|
| 2658 |
} |
| 2659 |
}else{
|
| 2660 |
/* different qscale, we must rescale */
|
| 2661 |
for(i=1;i<8;i++) { |
| 2662 |
block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
|
| 2663 |
} |
| 2664 |
} |
| 2665 |
} |
| 2666 |
} |
| 2667 |
/* left copy */
|
| 2668 |
for(i=1;i<8;i++) |
| 2669 |
ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
|
| 2670 |
|
| 2671 |
/* top copy */
|
| 2672 |
for(i=1;i<8;i++) |
| 2673 |
ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
|
| 2674 |
|
| 2675 |
} |
| 2676 |
|
| 2677 |
#ifdef CONFIG_ENCODERS
|
| 2678 |
|
| 2679 |
/**
|
| 2680 |
* encodes the dc value.
|
| 2681 |
* @param n block index (0-3 are luma, 4-5 are chroma)
|
| 2682 |
*/
|
| 2683 |
static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) |
| 2684 |
{
|
| 2685 |
#if 1 |
| 2686 |
// if(level<-255 || level>255) printf("dc overflow\n");
|
| 2687 |
level+=256;
|
| 2688 |
if (n < 4) { |
| 2689 |
/* luminance */
|
| 2690 |
put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); |
| 2691 |
} else {
|
| 2692 |
/* chrominance */
|
| 2693 |
put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); |
| 2694 |
} |
| 2695 |
#else
|
| 2696 |
int size, v;
|
| 2697 |
/* find number of bits */
|
| 2698 |
size = 0;
|
| 2699 |
v = abs(level); |
| 2700 |
while (v) {
|
| 2701 |
v >>= 1;
|
| 2702 |
size++; |
| 2703 |
} |
| 2704 |
|
| 2705 |
if (n < 4) { |
| 2706 |
/* luminance */
|
| 2707 |
put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); |
| 2708 |
} else {
|
| 2709 |
/* chrominance */
|
| 2710 |
put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); |
| 2711 |
} |
| 2712 |
|
| 2713 |
/* encode remaining bits */
|
| 2714 |
if (size > 0) { |
| 2715 |
if (level < 0) |
| 2716 |
level = (-level) ^ ((1 << size) - 1); |
| 2717 |
put_bits(&s->pb, size, level); |
| 2718 |
if (size > 8) |
| 2719 |
put_bits(&s->pb, 1, 1); |
| 2720 |
} |
| 2721 |
#endif
|
| 2722 |
} |
| 2723 |
|
| 2724 |
static inline int mpeg4_get_dc_length(int level, int n){ |
| 2725 |
if (n < 4) { |
| 2726 |
return uni_DCtab_lum_len[level + 256]; |
| 2727 |
} else {
|
| 2728 |
return uni_DCtab_chrom_len[level + 256]; |
| 2729 |
} |
| 2730 |
} |
| 2731 |
|
| 2732 |
/**
|
| 2733 |
* encodes a 8x8 block
|
| 2734 |
* @param n block index (0-3 are luma, 4-5 are chroma)
|
| 2735 |
*/
|
| 2736 |
static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
| 2737 |
uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
| 2738 |
{
|
| 2739 |
int i, last_non_zero;
|
| 2740 |
#if 0 //variables for the outcommented version
|
| 2741 |
int code, sign, last;
|
| 2742 |
#endif
|
| 2743 |
const RLTable *rl;
|
| 2744 |
uint32_t *bits_tab; |
| 2745 |
uint8_t *len_tab; |
| 2746 |
const int last_index = s->block_last_index[n]; |
| 2747 |
|
| 2748 |
if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
| 2749 |
/* mpeg4 based DC predictor */
|
| 2750 |
mpeg4_encode_dc(dc_pb, intra_dc, n); |
| 2751 |
if(last_index<1) return; |
| 2752 |
i = 1;
|
| 2753 |
rl = &rl_intra; |
| 2754 |
bits_tab= uni_mpeg4_intra_rl_bits; |
| 2755 |
len_tab = uni_mpeg4_intra_rl_len; |
| 2756 |
} else {
|
| 2757 |
if(last_index<0) return; |
| 2758 |
i = 0;
|
| 2759 |
rl = &rl_inter; |
| 2760 |
bits_tab= uni_mpeg4_inter_rl_bits; |
| 2761 |
len_tab = uni_mpeg4_inter_rl_len; |
| 2762 |
} |
| 2763 |
|
| 2764 |
/* AC coefs */
|
| 2765 |
last_non_zero = i - 1;
|
| 2766 |
#if 1 |
| 2767 |
for (; i < last_index; i++) {
|
| 2768 |
int level = block[ scan_table[i] ];
|
| 2769 |
if (level) {
|
| 2770 |
int run = i - last_non_zero - 1; |
| 2771 |
level+=64;
|
| 2772 |
if((level&(~127)) == 0){ |
| 2773 |
const int index= UNI_MPEG4_ENC_INDEX(0, run, level); |
| 2774 |
put_bits(ac_pb, len_tab[index], bits_tab[index]); |
| 2775 |
}else{ //ESC3 |
| 2776 |
put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); |
| 2777 |
} |
| 2778 |
last_non_zero = i; |
| 2779 |
} |
| 2780 |
} |
| 2781 |
/*if(i<=last_index)*/{
|
| 2782 |
int level = block[ scan_table[i] ];
|
| 2783 |
int run = i - last_non_zero - 1; |
| 2784 |
level+=64;
|
| 2785 |
if((level&(~127)) == 0){ |
| 2786 |
const int index= UNI_MPEG4_ENC_INDEX(1, run, level); |
| 2787 |
put_bits(ac_pb, len_tab[index], bits_tab[index]); |
| 2788 |
}else{ //ESC3 |
| 2789 |
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); |
| 2790 |
} |
| 2791 |
} |
| 2792 |
#else
|
| 2793 |
for (; i <= last_index; i++) {
|
| 2794 |
const int slevel = block[ scan_table[i] ]; |
| 2795 |
if (slevel) {
|
| 2796 |
int level;
|
| 2797 |
int run = i - last_non_zero - 1; |
| 2798 |
last = (i == last_index); |
| 2799 |
sign = 0;
|
| 2800 |
level = slevel; |
| 2801 |
if (level < 0) { |
| 2802 |
sign = 1;
|
| 2803 |
level = -level; |
| 2804 |
} |
| 2805 |
code = get_rl_index(rl, last, run, level); |
| 2806 |
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
| 2807 |
if (code == rl->n) {
|
| 2808 |
int level1, run1;
|
| 2809 |
level1 = level - rl->max_level[last][run]; |
| 2810 |
if (level1 < 1) |
| 2811 |
goto esc2;
|
| 2812 |
code = get_rl_index(rl, last, run, level1); |
| 2813 |
if (code == rl->n) {
|
| 2814 |
esc2:
|
| 2815 |
put_bits(ac_pb, 1, 1); |
| 2816 |
if (level > MAX_LEVEL)
|
| 2817 |
goto esc3;
|
| 2818 |
run1 = run - rl->max_run[last][level] - 1;
|
| 2819 |
if (run1 < 0) |
| 2820 |
goto esc3;
|
| 2821 |
code = get_rl_index(rl, last, run1, level); |
| 2822 |
if (code == rl->n) {
|
| 2823 |
esc3:
|
| 2824 |
/* third escape */
|
| 2825 |
put_bits(ac_pb, 1, 1); |
| 2826 |
put_bits(ac_pb, 1, last);
|
| 2827 |
put_bits(ac_pb, 6, run);
|
| 2828 |
put_bits(ac_pb, 1, 1); |
| 2829 |
put_bits(ac_pb, 12, slevel & 0xfff); |
| 2830 |
put_bits(ac_pb, 1, 1); |
| 2831 |
} else {
|
| 2832 |
/* second escape */
|
| 2833 |
put_bits(ac_pb, 1, 0); |
| 2834 |
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
| 2835 |
put_bits(ac_pb, 1, sign);
|
| 2836 |
} |
| 2837 |
} else {
|
| 2838 |
/* first escape */
|
| 2839 |
put_bits(ac_pb, 1, 0); |
| 2840 |
put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
| 2841 |
put_bits(ac_pb, 1, sign);
|
| 2842 |
} |
| 2843 |
} else {
|
| 2844 |
put_bits(ac_pb, 1, sign);
|
| 2845 |
} |
| 2846 |
last_non_zero = i; |
| 2847 |
} |
| 2848 |
} |
| 2849 |
#endif
|
| 2850 |
} |
| 2851 |
|
| 2852 |
static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
| 2853 |
uint8_t *scan_table) |
| 2854 |
{
|
| 2855 |
int i, last_non_zero;
|
| 2856 |
const RLTable *rl;
|
| 2857 |
uint8_t *len_tab; |
| 2858 |
const int last_index = s->block_last_index[n]; |
| 2859 |
int len=0; |
| 2860 |
|
| 2861 |
if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
| 2862 |
/* mpeg4 based DC predictor */
|
| 2863 |
len += mpeg4_get_dc_length(intra_dc, n); |
| 2864 |
if(last_index<1) return len; |
| 2865 |
i = 1;
|
| 2866 |
rl = &rl_intra; |
| 2867 |
len_tab = uni_mpeg4_intra_rl_len; |
| 2868 |
} else {
|
| 2869 |
if(last_index<0) return 0; |
| 2870 |
i = 0;
|
| 2871 |
rl = &rl_inter; |
| 2872 |
len_tab = uni_mpeg4_inter_rl_len; |
| 2873 |
} |
| 2874 |
|
| 2875 |
/* AC coefs */
|
| 2876 |
last_non_zero = i - 1;
|
| 2877 |
for (; i < last_index; i++) {
|
| 2878 |
int level = block[ scan_table[i] ];
|
| 2879 |
if (level) {
|
| 2880 |
int run = i - last_non_zero - 1; |
| 2881 |
level+=64;
|
| 2882 |
if((level&(~127)) == 0){ |
| 2883 |
const int index= UNI_MPEG4_ENC_INDEX(0, run, level); |
| 2884 |
len += len_tab[index]; |
| 2885 |
}else{ //ESC3 |
| 2886 |
len += 7+2+1+6+1+12+1; |
| 2887 |
} |
| 2888 |
last_non_zero = i; |
| 2889 |
} |
| 2890 |
} |
| 2891 |
/*if(i<=last_index)*/{
|
| 2892 |
int level = block[ scan_table[i] ];
|
| 2893 |
int run = i - last_non_zero - 1; |
| 2894 |
level+=64;
|
| 2895 |
if((level&(~127)) == 0){ |
| 2896 |
const int index= UNI_MPEG4_ENC_INDEX(1, run, level); |
| 2897 |
len += len_tab[index]; |
| 2898 |
}else{ //ESC3 |
| 2899 |
len += 7+2+1+6+1+12+1; |
| 2900 |
} |
| 2901 |
} |
| 2902 |
|
| 2903 |
return len;
|
| 2904 |
} |
| 2905 |
|
| 2906 |
#endif
|
| 2907 |
|
| 2908 |
|
| 2909 |
/***********************************************/
|
| 2910 |
/* decoding */
|
| 2911 |
|
| 2912 |
static VLC intra_MCBPC_vlc;
|
| 2913 |
static VLC inter_MCBPC_vlc;
|
| 2914 |
static VLC cbpy_vlc;
|
| 2915 |
static VLC mv_vlc;
|
| 2916 |
static VLC dc_lum, dc_chrom;
|
| 2917 |
static VLC sprite_trajectory;
|
| 2918 |
static VLC mb_type_b_vlc;
|
| 2919 |
static VLC h263_mbtype_b_vlc;
|
| 2920 |
static VLC cbpc_b_vlc;
|
| 2921 |
|
| 2922 |
void init_vlc_rl(RLTable *rl, int use_static) |
| 2923 |
{
|
| 2924 |
int i, q;
|
| 2925 |
|
| 2926 |
/* Return if static table is already initialized */
|
| 2927 |
if(use_static && rl->rl_vlc[0]) |
| 2928 |
return;
|
| 2929 |
|
| 2930 |
init_vlc(&rl->vlc, 9, rl->n + 1, |
| 2931 |
&rl->table_vlc[0][1], 4, 2, |
| 2932 |
&rl->table_vlc[0][0], 4, 2, use_static); |
| 2933 |
|
| 2934 |
|
| 2935 |
for(q=0; q<32; q++){ |
| 2936 |
int qmul= q*2; |
| 2937 |
int qadd= (q-1)|1; |
| 2938 |
|
| 2939 |
if(q==0){ |
| 2940 |
qmul=1;
|
| 2941 |
qadd=0;
|
| 2942 |
} |
| 2943 |
if(use_static)
|
| 2944 |
rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
|
| 2945 |
else
|
| 2946 |
rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
|
| 2947 |
for(i=0; i<rl->vlc.table_size; i++){ |
| 2948 |
int code= rl->vlc.table[i][0]; |
| 2949 |
int len = rl->vlc.table[i][1]; |
| 2950 |
int level, run;
|
| 2951 |
|
| 2952 |
if(len==0){ // illegal code |
| 2953 |
run= 66;
|
| 2954 |
level= MAX_LEVEL; |
| 2955 |
}else if(len<0){ //more bits needed |
| 2956 |
run= 0;
|
| 2957 |
level= code; |
| 2958 |
}else{
|
| 2959 |
if(code==rl->n){ //esc |
| 2960 |
run= 66;
|
| 2961 |
level= 0;
|
| 2962 |
}else{
|
| 2963 |
run= rl->table_run [code] + 1;
|
| 2964 |
level= rl->table_level[code] * qmul + qadd; |
| 2965 |
if(code >= rl->last) run+=192; |
| 2966 |
} |
| 2967 |
} |
| 2968 |
rl->rl_vlc[q][i].len= len; |
| 2969 |
rl->rl_vlc[q][i].level= level; |
| 2970 |
rl->rl_vlc[q][i].run= run; |
| 2971 |
} |
| 2972 |
} |
| 2973 |
} |
| 2974 |
|
| 2975 |
/* init vlcs */
|
| 2976 |
|
| 2977 |
/* XXX: find a better solution to handle static init */
|
| 2978 |
void h263_decode_init_vlc(MpegEncContext *s)
|
| 2979 |
{
|
| 2980 |
static int done = 0; |
| 2981 |
|
| 2982 |
if (!done) {
|
| 2983 |
done = 1;
|
| 2984 |
|
| 2985 |
init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
|
| 2986 |
intra_MCBPC_bits, 1, 1, |
| 2987 |
intra_MCBPC_code, 1, 1, 1); |
| 2988 |
init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
|
| 2989 |
inter_MCBPC_bits, 1, 1, |
| 2990 |
inter_MCBPC_code, 1, 1, 1); |
| 2991 |
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
|
| 2992 |
&cbpy_tab[0][1], 2, 1, |
| 2993 |
&cbpy_tab[0][0], 2, 1, 1); |
| 2994 |
init_vlc(&mv_vlc, MV_VLC_BITS, 33,
|
| 2995 |
&mvtab[0][1], 2, 1, |
| 2996 |
&mvtab[0][0], 2, 1, 1); |
| 2997 |
init_rl(&rl_inter, 1);
|
| 2998 |
init_rl(&rl_intra, 1);
|
| 2999 |
init_rl(&rvlc_rl_inter, 1);
|
| 3000 |
init_rl(&rvlc_rl_intra, 1);
|
| 3001 |
init_rl(&rl_intra_aic, 1);
|
| 3002 |
init_vlc_rl(&rl_inter, 1);
|
| 3003 |
init_vlc_rl(&rl_intra, 1);
|
| 3004 |
init_vlc_rl(&rvlc_rl_inter, 1);
|
| 3005 |
init_vlc_rl(&rvlc_rl_intra, 1);
|
| 3006 |
init_vlc_rl(&rl_intra_aic, 1);
|
| 3007 |
init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
| 3008 |
&DCtab_lum[0][1], 2, 1, |
| 3009 |
&DCtab_lum[0][0], 2, 1, 1); |
| 3010 |
init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, |
| 3011 |
&DCtab_chrom[0][1], 2, 1, |
| 3012 |
&DCtab_chrom[0][0], 2, 1, 1); |
| 3013 |
init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
|
| 3014 |
&sprite_trajectory_tab[0][1], 4, 2, |
| 3015 |
&sprite_trajectory_tab[0][0], 4, 2, 1); |
| 3016 |
init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
|
| 3017 |
&mb_type_b_tab[0][1], 2, 1, |
| 3018 |
&mb_type_b_tab[0][0], 2, 1, 1); |
| 3019 |
init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
|
| 3020 |
&h263_mbtype_b_tab[0][1], 2, 1, |
| 3021 |
&h263_mbtype_b_tab[0][0], 2, 1, 1); |
| 3022 |
init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
|
| 3023 |
&cbpc_b_tab[0][1], 2, 1, |
| 3024 |
&cbpc_b_tab[0][0], 2, 1, 1); |
| 3025 |
} |
| 3026 |
} |
| 3027 |
|
| 3028 |
/**
|
| 3029 |
* Get the GOB height based on picture height.
|
| 3030 |
*/
|
| 3031 |
int ff_h263_get_gob_height(MpegEncContext *s){
|
| 3032 |
if (s->height <= 400) |
| 3033 |
return 1; |
| 3034 |
else if (s->height <= 800) |
| 3035 |
return 2; |
| 3036 |
else
|
| 3037 |
return 4; |
| 3038 |
} |
| 3039 |
|
| 3040 |
int ff_h263_decode_mba(MpegEncContext *s)
|
| 3041 |
{
|
| 3042 |
int i, mb_pos;
|
| 3043 |
|
| 3044 |
for(i=0; i<6; i++){ |
| 3045 |
if(s->mb_num-1 <= ff_mba_max[i]) break; |
| 3046 |
} |
| 3047 |
mb_pos= get_bits(&s->gb, ff_mba_length[i]); |
| 3048 |
s->mb_x= mb_pos % s->mb_width; |
| 3049 |
s->mb_y= mb_pos / s->mb_width; |
| 3050 |
|
| 3051 |
return mb_pos;
|
| 3052 |
} |
| 3053 |
|
| 3054 |
void ff_h263_encode_mba(MpegEncContext *s)
|
| 3055 |
{
|
| 3056 |
int i, mb_pos;
|
| 3057 |
|
| 3058 |
for(i=0; i<6; i++){ |
| 3059 |
if(s->mb_num-1 <= ff_mba_max[i]) break; |
| 3060 |
} |
| 3061 |
mb_pos= s->mb_x + s->mb_width*s->mb_y; |
| 3062 |
put_bits(&s->pb, ff_mba_length[i], mb_pos); |
| 3063 |
} |
| 3064 |
|
| 3065 |
/**
|
| 3066 |
* decodes the group of blocks header or slice header.
|
| 3067 |
* @return <0 if an error occured
|
| 3068 |
*/
|
| 3069 |
static int h263_decode_gob_header(MpegEncContext *s) |
| 3070 |
{
|
| 3071 |
unsigned int val, gfid, gob_number; |
| 3072 |
int left;
|
| 3073 |
|
| 3074 |
/* Check for GOB Start Code */
|
| 3075 |
val = show_bits(&s->gb, 16);
|
| 3076 |
if(val)
|
| 3077 |
return -1; |
| 3078 |
|
| 3079 |
/* We have a GBSC probably with GSTUFF */
|
| 3080 |
skip_bits(&s->gb, 16); /* Drop the zeros */ |
| 3081 |
left= s->gb.size_in_bits - get_bits_count(&s->gb); |
| 3082 |
//MN: we must check the bits left or we might end in a infinite loop (or segfault)
|
| 3083 |
for(;left>13; left--){ |
| 3084 |
if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ |
| 3085 |
} |
| 3086 |
if(left<=13) |
| 3087 |
return -1; |
| 3088 |
|
| 3089 |
if(s->h263_slice_structured){
|
| 3090 |
if(get_bits1(&s->gb)==0) |
| 3091 |
return -1; |
| 3092 |
|
| 3093 |
ff_h263_decode_mba(s); |
| 3094 |
|
| 3095 |
if(s->mb_num > 1583) |
| 3096 |
if(get_bits1(&s->gb)==0) |
| 3097 |
return -1; |
| 3098 |
|
| 3099 |
s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
| 3100 |
if(get_bits1(&s->gb)==0) |
| 3101 |
return -1; |
| 3102 |
gfid = get_bits(&s->gb, 2); /* GFID */ |
| 3103 |
}else{
|
| 3104 |
gob_number = get_bits(&s->gb, 5); /* GN */ |
| 3105 |
s->mb_x= 0;
|
| 3106 |
s->mb_y= s->gob_index* gob_number; |
| 3107 |
gfid = get_bits(&s->gb, 2); /* GFID */ |
| 3108 |
s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
| 3109 |
} |
| 3110 |
|
| 3111 |
if(s->mb_y >= s->mb_height)
|
| 3112 |
return -1; |
| 3113 |
|
| 3114 |
if(s->qscale==0) |
| 3115 |
return -1; |
| 3116 |
|
| 3117 |
return 0; |
| 3118 |
} |
| 3119 |
|
| 3120 |
static inline void memsetw(short *tab, int val, int n) |
| 3121 |
{
|
| 3122 |
int i;
|
| 3123 |
for(i=0;i<n;i++) |
| 3124 |
tab[i] = val; |
| 3125 |
} |
| 3126 |
|
| 3127 |
#ifdef CONFIG_ENCODERS
|
| 3128 |
|
| 3129 |
void ff_mpeg4_init_partitions(MpegEncContext *s)
|
| 3130 |
{
|
| 3131 |
uint8_t *start= pbBufPtr(&s->pb); |
| 3132 |
uint8_t *end= s->pb.buf_end; |
| 3133 |
int size= end - start;
|
| 3134 |
int pb_size = (((long)start + size/3)&(~3)) - (long)start; |
| 3135 |
int tex_size= (size - 2*pb_size)&(~3); |
| 3136 |
|
| 3137 |
set_put_bits_buffer_size(&s->pb, pb_size); |
| 3138 |
init_put_bits(&s->tex_pb, start + pb_size , tex_size); |
| 3139 |
init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size); |
| 3140 |
} |
| 3141 |
|
| 3142 |
void ff_mpeg4_merge_partitions(MpegEncContext *s)
|
| 3143 |
{
|
| 3144 |
const int pb2_len = put_bits_count(&s->pb2 ); |
| 3145 |
const int tex_pb_len= put_bits_count(&s->tex_pb); |
| 3146 |
const int bits= put_bits_count(&s->pb); |
| 3147 |
|
| 3148 |
if(s->pict_type==I_TYPE){
|
| 3149 |
put_bits(&s->pb, 19, DC_MARKER);
|
| 3150 |
s->misc_bits+=19 + pb2_len + bits - s->last_bits;
|
| 3151 |
s->i_tex_bits+= tex_pb_len; |
| 3152 |
}else{
|
| 3153 |
put_bits(&s->pb, 17, MOTION_MARKER);
|
| 3154 |
s->misc_bits+=17 + pb2_len;
|
| 3155 |
s->mv_bits+= bits - s->last_bits; |
| 3156 |
s->p_tex_bits+= tex_pb_len; |
| 3157 |
} |
| 3158 |
|
| 3159 |
flush_put_bits(&s->pb2); |
| 3160 |
flush_put_bits(&s->tex_pb); |
| 3161 |
|
| 3162 |
set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf); |
| 3163 |
ff_copy_bits(&s->pb, s->pb2.buf , pb2_len); |
| 3164 |
ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len); |
| 3165 |
s->last_bits= put_bits_count(&s->pb); |
| 3166 |
} |
| 3167 |
|
| 3168 |
#endif //CONFIG_ENCODERS |
| 3169 |
|
| 3170 |
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
|
| 3171 |
switch(s->pict_type){
|
| 3172 |
case I_TYPE:
|
| 3173 |
return 16; |
| 3174 |
case P_TYPE:
|
| 3175 |
case S_TYPE:
|
| 3176 |
return s->f_code+15; |
| 3177 |
case B_TYPE:
|
| 3178 |
return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17); |
| 3179 |
default:
|
| 3180 |
return -1; |
| 3181 |
} |
| 3182 |
} |
| 3183 |
|
| 3184 |
#ifdef CONFIG_ENCODERS
|
| 3185 |
|
| 3186 |
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
|
| 3187 |
{
|
| 3188 |
int mb_num_bits= av_log2(s->mb_num - 1) + 1; |
| 3189 |
|
| 3190 |
put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
|
| 3191 |
put_bits(&s->pb, 1, 1); |
| 3192 |
|
| 3193 |
put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width); |
| 3194 |
put_bits(&s->pb, s->quant_precision, s->qscale); |
| 3195 |
put_bits(&s->pb, 1, 0); /* no HEC */ |
| 3196 |
} |
| 3197 |
|
| 3198 |
#endif //CONFIG_ENCODERS |
| 3199 |
|
| 3200 |
/**
|
| 3201 |
* check if the next stuff is a resync marker or the end.
|
| 3202 |
* @return 0 if not
|
| 3203 |
*/
|
| 3204 |
static inline int mpeg4_is_resync(MpegEncContext *s){ |
| 3205 |
int bits_count= get_bits_count(&s->gb);
|
| 3206 |
int v= show_bits(&s->gb, 16); |
| 3207 |
|
| 3208 |
if(s->workaround_bugs&FF_BUG_NO_PADDING){
|
| 3209 |
return 0; |
| 3210 |
} |
| 3211 |
|
| 3212 |
while(v<=0xFF){ |
| 3213 |
if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame) |
| 3214 |
break;
|
| 3215 |
skip_bits(&s->gb, 8+s->pict_type);
|
| 3216 |
bits_count+= 8+s->pict_type;
|
| 3217 |
v= show_bits(&s->gb, 16);
|
| 3218 |
} |
| 3219 |
|
| 3220 |
if(bits_count + 8 >= s->gb.size_in_bits){ |
| 3221 |
v>>=8;
|
| 3222 |
v|= 0x7F >> (7-(bits_count&7)); |
| 3223 |
|
| 3224 |
if(v==0x7F) |
| 3225 |
return 1; |
| 3226 |
}else{
|
| 3227 |
if(v == ff_mpeg4_resync_prefix[bits_count&7]){ |
| 3228 |
int len;
|
| 3229 |
GetBitContext gb= s->gb; |
| 3230 |
|
| 3231 |
skip_bits(&s->gb, 1);
|
| 3232 |
align_get_bits(&s->gb); |
| 3233 |
|
| 3234 |
for(len=0; len<32; len++){ |
| 3235 |
if(get_bits1(&s->gb)) break; |
| 3236 |
} |
| 3237 |
|
| 3238 |
s->gb= gb; |
| 3239 |
|
| 3240 |
if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
|
| 3241 |
return 1; |
| 3242 |
} |
| 3243 |
} |
| 3244 |
return 0; |
| 3245 |
} |
| 3246 |
|
| 3247 |
/**
|
| 3248 |
* decodes the next video packet.
|
| 3249 |
* @return <0 if something went wrong
|
| 3250 |
*/
|
| 3251 |
static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
| 3252 |
{
|
| 3253 |
int mb_num_bits= av_log2(s->mb_num - 1) + 1; |
| 3254 |
int header_extension=0, mb_num, len; |
| 3255 |
|
| 3256 |
/* is there enough space left for a video packet + header */
|
| 3257 |
if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1; |
| 3258 |
|
| 3259 |
for(len=0; len<32; len++){ |
| 3260 |
if(get_bits1(&s->gb)) break; |
| 3261 |
} |
| 3262 |
|
| 3263 |
if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
|
| 3264 |
av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
|
| 3265 |
return -1; |
| 3266 |
} |
| 3267 |
|
| 3268 |
if(s->shape != RECT_SHAPE){
|
| 3269 |
header_extension= get_bits1(&s->gb); |
| 3270 |
//FIXME more stuff here
|
| 3271 |
} |
| 3272 |
|
| 3273 |
mb_num= get_bits(&s->gb, mb_num_bits); |
| 3274 |
if(mb_num>=s->mb_num){
|
| 3275 |
av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
|
| 3276 |
return -1; |
| 3277 |
} |
| 3278 |
if(s->pict_type == B_TYPE){
|
| 3279 |
while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
|
| 3280 |
if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded |
| 3281 |
} |
| 3282 |
|
| 3283 |
s->mb_x= mb_num % s->mb_width; |
| 3284 |
s->mb_y= mb_num / s->mb_width; |
| 3285 |
|
| 3286 |
if(s->shape != BIN_ONLY_SHAPE){
|
| 3287 |
int qscale= get_bits(&s->gb, s->quant_precision);
|
| 3288 |
if(qscale)
|
| 3289 |
s->chroma_qscale=s->qscale= qscale; |
| 3290 |
} |
| 3291 |
|
| 3292 |
if(s->shape == RECT_SHAPE){
|
| 3293 |
header_extension= get_bits1(&s->gb); |
| 3294 |
} |
| 3295 |
if(header_extension){
|
| 3296 |
int time_increment;
|
| 3297 |
int time_incr=0; |
| 3298 |
|
| 3299 |
while (get_bits1(&s->gb) != 0) |
| 3300 |
time_incr++; |
| 3301 |
|
| 3302 |
check_marker(&s->gb, "before time_increment in video packed header");
|
| 3303 |
time_increment= get_bits(&s->gb, s->time_increment_bits); |
| 3304 |
check_marker(&s->gb, "before vop_coding_type in video packed header");
|
| 3305 |
|
| 3306 |
skip_bits(&s->gb, 2); /* vop coding type */ |
| 3307 |
//FIXME not rect stuff here
|
| 3308 |
|
| 3309 |
if(s->shape != BIN_ONLY_SHAPE){
|
| 3310 |
skip_bits(&s->gb, 3); /* intra dc vlc threshold */ |
| 3311 |
//FIXME don't just ignore everything
|
| 3312 |
if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
|
| 3313 |
mpeg4_decode_sprite_trajectory(s, &s->gb); |
| 3314 |
av_log(s->avctx, AV_LOG_ERROR, "untested\n");
|
| 3315 |
} |
| 3316 |
|
| 3317 |
//FIXME reduced res stuff here
|
| 3318 |
|
| 3319 |
if (s->pict_type != I_TYPE) {
|
| 3320 |
int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
| 3321 |
if(f_code==0){ |
| 3322 |
av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
|
| 3323 |
} |
| 3324 |
} |
| 3325 |
if (s->pict_type == B_TYPE) {
|
| 3326 |
int b_code = get_bits(&s->gb, 3); |
| 3327 |
if(b_code==0){ |
| 3328 |
av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
|
| 3329 |
} |
| 3330 |
} |
| 3331 |
} |
| 3332 |
} |
| 3333 |
//FIXME new-pred stuff
|
| 3334 |
|
| 3335 |
//printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
|
| 3336 |
|
| 3337 |
return 0; |
| 3338 |
} |
| 3339 |
|
| 3340 |
void ff_mpeg4_clean_buffers(MpegEncContext *s)
|
| 3341 |
{
|
| 3342 |
int c_wrap, c_xy, l_wrap, l_xy;
|
| 3343 |
|
| 3344 |
l_wrap= s->b8_stride; |
| 3345 |
l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1; |
| 3346 |
c_wrap= s->mb_stride; |
| 3347 |
c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1; |
| 3348 |
|
| 3349 |
#if 0
|
| 3350 |
/* clean DC */
|
| 3351 |
memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
|
| 3352 |
memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
|
| 3353 |
memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
|
| 3354 |
#endif
|
| 3355 |
|
| 3356 |
/* clean AC */
|
| 3357 |
memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
| 3358 |
memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); |
| 3359 |
memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); |
| 3360 |
|
| 3361 |
/* clean MV */
|
| 3362 |
// we can't clear the MVs as they might be needed by a b frame
|
| 3363 |
// memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
|
| 3364 |
// memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
|
| 3365 |
s->last_mv[0][0][0]= |
| 3366 |
s->last_mv[0][0][1]= |
| 3367 |
s->last_mv[1][0][0]= |
| 3368 |
s->last_mv[1][0][1]= 0; |
| 3369 |
} |
| 3370 |
|
| 3371 |
/**
|
| 3372 |
* decodes the group of blocks / video packet header.
|
| 3373 |
* @return <0 if no resync found
|
| 3374 |
*/
|
| 3375 |
int ff_h263_resync(MpegEncContext *s){
|
| 3376 |
int left, ret;
|
| 3377 |
|
| 3378 |
if(s->codec_id==CODEC_ID_MPEG4){
|
| 3379 |
skip_bits1(&s->gb); |
| 3380 |
align_get_bits(&s->gb); |
| 3381 |
} |
| 3382 |
|
| 3383 |
if(show_bits(&s->gb, 16)==0){ |
| 3384 |
if(s->codec_id==CODEC_ID_MPEG4)
|
| 3385 |
ret= mpeg4_decode_video_packet_header(s); |
| 3386 |
else
|
| 3387 |
ret= h263_decode_gob_header(s); |
| 3388 |
if(ret>=0) |
| 3389 |
return 0; |
| 3390 |
} |
| 3391 |
//ok, it's not where its supposed to be ...
|
| 3392 |
s->gb= s->last_resync_gb; |
| 3393 |
align_get_bits(&s->gb); |
| 3394 |
left= s->gb.size_in_bits - get_bits_count(&s->gb); |
| 3395 |
|
| 3396 |
for(;left>16+1+5+5; left-=8){ |
| 3397 |
if(show_bits(&s->gb, 16)==0){ |
| 3398 |
GetBitContext bak= s->gb; |
| 3399 |
|
| 3400 |
if(s->codec_id==CODEC_ID_MPEG4)
|
| 3401 |
ret= mpeg4_decode_video_packet_header(s); |
| 3402 |
else
|
| 3403 |
ret= h263_decode_gob_header(s); |
| 3404 |
if(ret>=0) |
| 3405 |
return 0; |
| 3406 |
|
| 3407 |
s->gb= bak; |
| 3408 |
} |
| 3409 |
skip_bits(&s->gb, 8);
|
| 3410 |
} |
| 3411 |
|
| 3412 |
return -1; |
| 3413 |
} |
| 3414 |
|
| 3415 |
/**
|
| 3416 |
* gets the average motion vector for a GMC MB.
|
| 3417 |
* @param n either 0 for the x component or 1 for y
|
| 3418 |
* @returns the average MV for a GMC MB
|
| 3419 |
*/
|
| 3420 |
static inline int get_amv(MpegEncContext *s, int n){ |
| 3421 |
int x, y, mb_v, sum, dx, dy, shift;
|
| 3422 |
int len = 1 << (s->f_code + 4); |
| 3423 |
const int a= s->sprite_warping_accuracy; |
| 3424 |
|
| 3425 |
if(s->workaround_bugs & FF_BUG_AMV)
|
| 3426 |
len >>= s->quarter_sample; |
| 3427 |
|
| 3428 |
if(s->real_sprite_warping_points==1){ |
| 3429 |
if(s->divx_version==500 && s->divx_build==413) |
| 3430 |
sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); |
| 3431 |
else
|
| 3432 |
sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
|
| 3433 |
}else{
|
| 3434 |
dx= s->sprite_delta[n][0];
|
| 3435 |
dy= s->sprite_delta[n][1];
|
| 3436 |
shift= s->sprite_shift[0];
|
| 3437 |
if(n) dy -= 1<<(shift + a + 1); |
| 3438 |
else dx -= 1<<(shift + a + 1); |
| 3439 |
mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; |
| 3440 |
|
| 3441 |
sum=0;
|
| 3442 |
for(y=0; y<16; y++){ |
| 3443 |
int v;
|
| 3444 |
|
| 3445 |
v= mb_v + dy*y; |
| 3446 |
//XXX FIXME optimize
|
| 3447 |
for(x=0; x<16; x++){ |
| 3448 |
sum+= v>>shift; |
| 3449 |
v+= dx; |
| 3450 |
} |
| 3451 |
} |
| 3452 |
sum= RSHIFT(sum, a+8-s->quarter_sample);
|
| 3453 |
} |
| 3454 |
|
| 3455 |
if (sum < -len) sum= -len;
|
| 3456 |
else if (sum >= len) sum= len-1; |
| 3457 |
|
| 3458 |
return sum;
|
| 3459 |
} |
| 3460 |
|
| 3461 |
/**
|
| 3462 |
* decodes first partition.
|
| 3463 |
* @return number of MBs decoded or <0 if an error occured
|
| 3464 |
*/
|
| 3465 |
static int mpeg4_decode_partition_a(MpegEncContext *s){ |
| 3466 |
int mb_num;
|
| 3467 |
static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
| 3468 |
|
| 3469 |
/* decode first partition */
|
| 3470 |
mb_num=0;
|
| 3471 |
s->first_slice_line=1;
|
| 3472 |
for(; s->mb_y<s->mb_height; s->mb_y++){
|
| 3473 |
ff_init_block_index(s); |
| 3474 |
for(; s->mb_x<s->mb_width; s->mb_x++){
|
| 3475 |
const int xy= s->mb_x + s->mb_y*s->mb_stride; |
| 3476 |
int cbpc;
|
| 3477 |
int dir=0; |
| 3478 |
|
| 3479 |
mb_num++; |
| 3480 |
ff_update_block_index(s); |
| 3481 |
if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
| 3482 |
s->first_slice_line=0;
|
| 3483 |
|
| 3484 |
if(s->pict_type==I_TYPE){
|
| 3485 |
int i;
|
| 3486 |
|
| 3487 |
do{
|
| 3488 |
if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
| 3489 |
return mb_num-1; |
| 3490 |
} |
| 3491 |
|
| 3492 |
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
|
| 3493 |
if (cbpc < 0){ |
| 3494 |
av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
|
| 3495 |
return -1; |
| 3496 |
} |
| 3497 |
}while(cbpc == 8); |
| 3498 |
|
| 3499 |
s->cbp_table[xy]= cbpc & 3;
|
| 3500 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
| 3501 |
s->mb_intra = 1;
|
| 3502 |
|
| 3503 |
if(cbpc & 4) { |
| 3504 |
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
|
| 3505 |
} |
| 3506 |
s->current_picture.qscale_table[xy]= s->qscale; |
| 3507 |
|
| 3508 |
s->mbintra_table[xy]= 1;
|
| 3509 |
for(i=0; i<6; i++){ |
| 3510 |
int dc_pred_dir;
|
| 3511 |
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
|
| 3512 |
if(dc < 0){ |
| 3513 |
av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
|
| 3514 |
return -1; |
| 3515 |
} |
| 3516 |
dir<<=1;
|
| 3517 |
if(dc_pred_dir) dir|=1; |
| 3518 |
} |
| 3519 |
s->pred_dir_table[xy]= dir; |
| 3520 |
}else{ /* P/S_TYPE */ |
| 3521 |
int mx, my, pred_x, pred_y, bits;
|
| 3522 |
int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]]; |
| 3523 |
const int stride= s->b8_stride*2; |
| 3524 |
|
| 3525 |
try_again:
|
| 3526 |
bits= show_bits(&s->gb, 17);
|
| 3527 |
if(bits==MOTION_MARKER){
|
| 3528 |
return mb_num-1; |
| 3529 |
} |
| 3530 |
skip_bits1(&s->gb); |
| 3531 |
if(bits&0x10000){ |
| 3532 |
/* skip mb */
|
| 3533 |
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
|
| 3534 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
| 3535 |
mx= get_amv(s, 0);
|
| 3536 |
my= get_amv(s, 1);
|
| 3537 |
}else{
|
| 3538 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
| 3539 |
mx=my=0;
|
| 3540 |
} |
| 3541 |
mot_val[0 ]= mot_val[2 ]= |
| 3542 |
mot_val[0+stride]= mot_val[2+stride]= mx; |
| 3543 |
mot_val[1 ]= mot_val[3 ]= |
| 3544 |
mot_val[1+stride]= mot_val[3+stride]= my; |
| 3545 |
|
| 3546 |
if(s->mbintra_table[xy])
|
| 3547 |
ff_clean_intra_table_entries(s); |
| 3548 |
continue;
|
| 3549 |
} |
| 3550 |
|
| 3551 |
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
|
| 3552 |
if (cbpc < 0){ |
| 3553 |
av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
|
| 3554 |
return -1; |
| 3555 |
} |
| 3556 |
if(cbpc == 20) |
| 3557 |
goto try_again;
|
| 3558 |
|
| 3559 |
s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
| 3560 |
|
| 3561 |
s->mb_intra = ((cbpc & 4) != 0); |
| 3562 |
|
| 3563 |
if(s->mb_intra){
|
| 3564 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
| 3565 |
s->mbintra_table[xy]= 1;
|
| 3566 |
mot_val[0 ]= mot_val[2 ]= |
| 3567 |
mot_val[0+stride]= mot_val[2+stride]= 0; |
| 3568 |
mot_val[1 ]= mot_val[3 ]= |
| 3569 |
mot_val[1+stride]= mot_val[3+stride]= 0; |
| 3570 |
}else{
|
| 3571 |
if(s->mbintra_table[xy])
|
| 3572 |
ff_clean_intra_table_entries(s); |
| 3573 |
|
| 3574 |
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
| 3575 |
s->mcsel= get_bits1(&s->gb); |
| 3576 |
else s->mcsel= 0; |
| 3577 |
|
| 3578 |
if ((cbpc & 16) == 0) { |
| 3579 |
/* 16x16 motion prediction */
|
| 3580 |
|
| 3581 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 3582 |
if(!s->mcsel){
|
| 3583 |
mx = h263_decode_motion(s, pred_x, s->f_code); |
| 3584 |
if (mx >= 0xffff) |
| 3585 |
return -1; |
| 3586 |
|
| 3587 |
my = h263_decode_motion(s, pred_y, s->f_code); |
| 3588 |
if (my >= 0xffff) |
| 3589 |
return -1; |
| 3590 |
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
| 3591 |
} else {
|
| 3592 |
mx = get_amv(s, 0);
|
| 3593 |
my = get_amv(s, 1);
|
| 3594 |
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
| 3595 |
} |
| 3596 |
|
| 3597 |
mot_val[0 ]= mot_val[2 ] = |
| 3598 |
mot_val[0+stride]= mot_val[2+stride]= mx; |
| 3599 |
mot_val[1 ]= mot_val[3 ]= |
| 3600 |
mot_val[1+stride]= mot_val[3+stride]= my; |
| 3601 |
} else {
|
| 3602 |
int i;
|
| 3603 |
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
| 3604 |
for(i=0;i<4;i++) { |
| 3605 |
int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
|
| 3606 |
mx = h263_decode_motion(s, pred_x, s->f_code); |
| 3607 |
if (mx >= 0xffff) |
| 3608 |
return -1; |
| 3609 |
|
| 3610 |
my = h263_decode_motion(s, pred_y, s->f_code); |
| 3611 |
if (my >= 0xffff) |
| 3612 |
return -1; |
| 3613 |
mot_val[0] = mx;
|
| 3614 |
mot_val[1] = my;
|
| 3615 |
} |
| 3616 |
} |
| 3617 |
} |
| 3618 |
} |
| 3619 |
} |
| 3620 |
s->mb_x= 0;
|
| 3621 |
} |
| 3622 |
|
| 3623 |
return mb_num;
|
| 3624 |
} |
| 3625 |
|
| 3626 |
/**
|
| 3627 |
* decode second partition.
|
| 3628 |
* @return <0 if an error occured
|
| 3629 |
*/
|
| 3630 |
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){ |
| 3631 |
int mb_num=0; |
| 3632 |
static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
| 3633 |
|
| 3634 |
s->mb_x= s->resync_mb_x; |
| 3635 |
s->first_slice_line=1;
|
| 3636 |
for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
|
| 3637 |
ff_init_block_index(s); |
| 3638 |
for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
|
| 3639 |
const int xy= s->mb_x + s->mb_y*s->mb_stride; |
| 3640 |
|
| 3641 |
mb_num++; |
| 3642 |
ff_update_block_index(s); |
| 3643 |
if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
| 3644 |
s->first_slice_line=0;
|
| 3645 |
|
| 3646 |
if(s->pict_type==I_TYPE){
|
| 3647 |
int ac_pred= get_bits1(&s->gb);
|
| 3648 |
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
| 3649 |
if(cbpy<0){ |
| 3650 |
av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
|
| 3651 |
return -1; |
| 3652 |
} |
| 3653 |
|
| 3654 |
s->cbp_table[xy]|= cbpy<<2;
|
| 3655 |
s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
| 3656 |
}else{ /* P || S_TYPE */ |
| 3657 |
if(IS_INTRA(s->current_picture.mb_type[xy])){
|
| 3658 |
int dir=0,i; |
| 3659 |
int ac_pred = get_bits1(&s->gb);
|
| 3660 |
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
| 3661 |
|
| 3662 |
if(cbpy<0){ |
| 3663 |
av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
|
| 3664 |
return -1; |
| 3665 |
} |
| 3666 |
|
| 3667 |
if(s->cbp_table[xy] & 8) { |
| 3668 |
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
|
| 3669 |
} |
| 3670 |
s->current_picture.qscale_table[xy]= s->qscale; |
| 3671 |
|
| 3672 |
for(i=0; i<6; i++){ |
| 3673 |
int dc_pred_dir;
|
| 3674 |
int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
|
| 3675 |
if(dc < 0){ |
| 3676 |
av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
|
| 3677 |
return -1; |
| 3678 |
} |
| 3679 |
dir<<=1;
|
| 3680 |
if(dc_pred_dir) dir|=1; |
| 3681 |
} |
| 3682 |
s->cbp_table[xy]&= 3; //remove dquant |
| 3683 |
s->cbp_table[xy]|= cbpy<<2;
|
| 3684 |
s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
| 3685 |
s->pred_dir_table[xy]= dir; |
| 3686 |
}else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
| 3687 |
s->current_picture.qscale_table[xy]= s->qscale; |
| 3688 |
s->cbp_table[xy]= 0;
|
| 3689 |
}else{
|
| 3690 |
int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
| 3691 |
|
| 3692 |
if(cbpy<0){ |
| 3693 |
av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
|
| 3694 |
return -1; |
| 3695 |
} |
| 3696 |
|
| 3697 |
if(s->cbp_table[xy] & 8) { |
| 3698 |
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
|
| 3699 |
} |
| 3700 |
s->current_picture.qscale_table[xy]= s->qscale; |
| 3701 |
|
| 3702 |
s->cbp_table[xy]&= 3; //remove dquant |
| 3703 |
s->cbp_table[xy]|= (cbpy^0xf)<<2; |
| 3704 |
} |
| 3705 |
} |
| 3706 |
} |
| 3707 |
if(mb_num >= mb_count) return 0; |
| 3708 |
s->mb_x= 0;
|
| 3709 |
} |
| 3710 |
return 0; |
| 3711 |
} |
| 3712 |
|
| 3713 |
/**
|
| 3714 |
* decodes the first & second partition
|
| 3715 |
* @return <0 if error (and sets error type in the error_status_table)
|
| 3716 |
*/
|
| 3717 |
int ff_mpeg4_decode_partitions(MpegEncContext *s)
|
| 3718 |
{
|
| 3719 |
int mb_num;
|
| 3720 |
const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
| 3721 |
const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END; |
| 3722 |
|
| 3723 |
mb_num= mpeg4_decode_partition_a(s); |
| 3724 |
if(mb_num<0){ |
| 3725 |
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); |
| 3726 |
return -1; |
| 3727 |
} |
| 3728 |
|
| 3729 |
if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
|
| 3730 |
av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
|
| 3731 |
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); |
| 3732 |
return -1; |
| 3733 |
} |
| 3734 |
|
| 3735 |
s->mb_num_left= mb_num; |
| 3736 |
|
| 3737 |
if(s->pict_type==I_TYPE){
|
| 3738 |
while(show_bits(&s->gb, 9) == 1) |
| 3739 |
skip_bits(&s->gb, 9);
|
| 3740 |
if(get_bits_long(&s->gb, 19)!=DC_MARKER){ |
| 3741 |
av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
|
| 3742 |
return -1; |
| 3743 |
} |
| 3744 |
}else{
|
| 3745 |
while(show_bits(&s->gb, 10) == 1) |
| 3746 |
skip_bits(&s->gb, 10);
|
| 3747 |
if(get_bits(&s->gb, 17)!=MOTION_MARKER){ |
| 3748 |
av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
|
| 3749 |
return -1; |
| 3750 |
} |
| 3751 |
} |
| 3752 |
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
|
| 3753 |
|
| 3754 |
if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
| 3755 |
if(s->pict_type==P_TYPE)
|
| 3756 |
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR); |
| 3757 |
return -1; |
| 3758 |
}else{
|
| 3759 |
if(s->pict_type==P_TYPE)
|
| 3760 |
ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
|
| 3761 |
} |
| 3762 |
|
| 3763 |
return 0; |
| 3764 |
} |
| 3765 |
|
| 3766 |
/**
|
| 3767 |
* decode partition C of one MB.
|
| 3768 |
* @return <0 if an error occured
|
| 3769 |
*/
|
| 3770 |
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
| 3771 |
{
|
| 3772 |
int cbp, mb_type;
|
| 3773 |
const int xy= s->mb_x + s->mb_y*s->mb_stride; |
| 3774 |
|
| 3775 |
mb_type= s->current_picture.mb_type[xy]; |
| 3776 |
cbp = s->cbp_table[xy]; |
| 3777 |
|
| 3778 |
s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; |
| 3779 |
|
| 3780 |
if(s->current_picture.qscale_table[xy] != s->qscale){
|
| 3781 |
ff_set_qscale(s, s->current_picture.qscale_table[xy] ); |
| 3782 |
} |
| 3783 |
|
| 3784 |
if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
|
| 3785 |
int i;
|
| 3786 |
for(i=0; i<4; i++){ |
| 3787 |
s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0]; |
| 3788 |
s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
| 3789 |
} |
| 3790 |
s->mb_intra = IS_INTRA(mb_type); |
| 3791 |
|
| 3792 |
if (IS_SKIP(mb_type)) {
|
| 3793 |
/* skip mb */
|
| 3794 |
for(i=0;i<6;i++) |
| 3795 |
s->block_last_index[i] = -1;
|
| 3796 |
s->mv_dir = MV_DIR_FORWARD; |
| 3797 |
s->mv_type = MV_TYPE_16X16; |
| 3798 |
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
|
| 3799 |
s->mcsel=1;
|
| 3800 |
s->mb_skipped = 0;
|
| 3801 |
}else{
|
| 3802 |
s->mcsel=0;
|
| 3803 |
s->mb_skipped = 1;
|
| 3804 |
} |
| 3805 |
}else if(s->mb_intra){ |
| 3806 |
s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
| 3807 |
}else if(!s->mb_intra){ |
| 3808 |
// s->mcsel= 0; //FIXME do we need to init that
|
| 3809 |
|
| 3810 |
s->mv_dir = MV_DIR_FORWARD; |
| 3811 |
if (IS_8X8(mb_type)) {
|
| 3812 |
s->mv_type = MV_TYPE_8X8; |
| 3813 |
} else {
|
| 3814 |
s->mv_type = MV_TYPE_16X16; |
| 3815 |
} |
| 3816 |
} |
| 3817 |
} else { /* I-Frame */ |
| 3818 |
s->mb_intra = 1;
|
| 3819 |
s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
| 3820 |
} |
| 3821 |
|
| 3822 |
if (!IS_SKIP(mb_type)) {
|
| 3823 |
int i;
|
| 3824 |
s->dsp.clear_blocks(s->block[0]);
|
| 3825 |
/* decode each block */
|
| 3826 |
for (i = 0; i < 6; i++) { |
| 3827 |
if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ |
| 3828 |
av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
|
| 3829 |
return -1; |
| 3830 |
} |
| 3831 |
cbp+=cbp; |
| 3832 |
} |
| 3833 |
} |
| 3834 |
|
| 3835 |
/* per-MB end of slice check */
|
| 3836 |
|
| 3837 |
if(--s->mb_num_left <= 0){ |
| 3838 |
//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
|
| 3839 |
if(mpeg4_is_resync(s))
|
| 3840 |
return SLICE_END;
|
| 3841 |
else
|
| 3842 |
return SLICE_NOEND;
|
| 3843 |
}else{
|
| 3844 |
if(mpeg4_is_resync(s)){
|
| 3845 |
const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
| 3846 |
if(s->cbp_table[xy+delta])
|
| 3847 |
return SLICE_END;
|
| 3848 |
} |
| 3849 |
return SLICE_OK;
|
| 3850 |
} |
| 3851 |
} |
| 3852 |
|
| 3853 |
/**
|
| 3854 |
* read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
|
| 3855 |
*/
|
| 3856 |
static void preview_obmc(MpegEncContext *s){ |
| 3857 |
GetBitContext gb= s->gb; |
| 3858 |
|
| 3859 |
int cbpc, i, pred_x, pred_y, mx, my;
|
| 3860 |
int16_t *mot_val; |
| 3861 |
const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; |
| 3862 |
const int stride= s->b8_stride*2; |
| 3863 |
|
| 3864 |
for(i=0; i<4; i++) |
| 3865 |
s->block_index[i]+= 2;
|
| 3866 |
for(i=4; i<6; i++) |
| 3867 |
s->block_index[i]+= 1;
|
| 3868 |
s->mb_x++; |
| 3869 |
|
| 3870 |
assert(s->pict_type == P_TYPE); |
| 3871 |
|
| 3872 |
do{
|
| 3873 |
if (get_bits1(&s->gb)) {
|
| 3874 |
/* skip mb */
|
| 3875 |
mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; |
| 3876 |
mot_val[0 ]= mot_val[2 ]= |
| 3877 |
mot_val[0+stride]= mot_val[2+stride]= 0; |
| 3878 |
mot_val[1 ]= mot_val[3 ]= |
| 3879 |
mot_val[1+stride]= mot_val[3+stride]= 0; |
| 3880 |
|
| 3881 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
| 3882 |
goto end;
|
| 3883 |
} |
| 3884 |
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
|
| 3885 |
}while(cbpc == 20); |
| 3886 |
|
| 3887 |
if(cbpc & 4){ |
| 3888 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
| 3889 |
}else{
|
| 3890 |
get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
|
| 3891 |
if (cbpc & 8) { |
| 3892 |
if(s->modified_quant){
|
| 3893 |
if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); |
| 3894 |
else skip_bits(&s->gb, 5); |
| 3895 |
}else
|
| 3896 |
skip_bits(&s->gb, 2);
|
| 3897 |
} |
| 3898 |
|
| 3899 |
if ((cbpc & 16) == 0) { |
| 3900 |
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
| 3901 |
/* 16x16 motion prediction */
|
| 3902 |
mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 3903 |
if (s->umvplus)
|
| 3904 |
mx = h263p_decode_umotion(s, pred_x); |
| 3905 |
else
|
| 3906 |
mx = h263_decode_motion(s, pred_x, 1);
|
| 3907 |
|
| 3908 |
if (s->umvplus)
|
| 3909 |
my = h263p_decode_umotion(s, pred_y); |
| 3910 |
else
|
| 3911 |
my = h263_decode_motion(s, pred_y, 1);
|
| 3912 |
|
| 3913 |
mot_val[0 ]= mot_val[2 ]= |
| 3914 |
mot_val[0+stride]= mot_val[2+stride]= mx; |
| 3915 |
mot_val[1 ]= mot_val[3 ]= |
| 3916 |
mot_val[1+stride]= mot_val[3+stride]= my; |
| 3917 |
} else {
|
| 3918 |
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
| 3919 |
for(i=0;i<4;i++) { |
| 3920 |
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
|
| 3921 |
if (s->umvplus)
|
| 3922 |
mx = h263p_decode_umotion(s, pred_x); |
| 3923 |
else
|
| 3924 |
mx = h263_decode_motion(s, pred_x, 1);
|
| 3925 |
|
| 3926 |
if (s->umvplus)
|
| 3927 |
my = h263p_decode_umotion(s, pred_y); |
| 3928 |
else
|
| 3929 |
my = h263_decode_motion(s, pred_y, 1);
|
| 3930 |
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
| 3931 |
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
|
| 3932 |
mot_val[0] = mx;
|
| 3933 |
mot_val[1] = my;
|
| 3934 |
} |
| 3935 |
} |
| 3936 |
} |
| 3937 |
end:
|
| 3938 |
|
| 3939 |
for(i=0; i<4; i++) |
| 3940 |
s->block_index[i]-= 2;
|
| 3941 |
for(i=4; i<6; i++) |
| 3942 |
s->block_index[i]-= 1;
|
| 3943 |
s->mb_x--; |
| 3944 |
|
| 3945 |
s->gb= gb; |
| 3946 |
} |
| 3947 |
|
| 3948 |
static void h263_decode_dquant(MpegEncContext *s){ |
| 3949 |
static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
| 3950 |
|
| 3951 |
if(s->modified_quant){
|
| 3952 |
if(get_bits1(&s->gb))
|
| 3953 |
s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; |
| 3954 |
else
|
| 3955 |
s->qscale= get_bits(&s->gb, 5);
|
| 3956 |
}else
|
| 3957 |
s->qscale += quant_tab[get_bits(&s->gb, 2)];
|
| 3958 |
ff_set_qscale(s, s->qscale); |
| 3959 |
} |
| 3960 |
|
| 3961 |
int ff_h263_decode_mb(MpegEncContext *s,
|
| 3962 |
DCTELEM block[6][64]) |
| 3963 |
{
|
| 3964 |
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
|
| 3965 |
int16_t *mot_val; |
| 3966 |
const int xy= s->mb_x + s->mb_y * s->mb_stride; |
| 3967 |
|
| 3968 |
assert(!s->h263_pred); |
| 3969 |
|
| 3970 |
if (s->pict_type == P_TYPE) {
|
| 3971 |
do{
|
| 3972 |
if (get_bits1(&s->gb)) {
|
| 3973 |
/* skip mb */
|
| 3974 |
s->mb_intra = 0;
|
| 3975 |
for(i=0;i<6;i++) |
| 3976 |
s->block_last_index[i] = -1;
|
| 3977 |
s->mv_dir = MV_DIR_FORWARD; |
| 3978 |
s->mv_type = MV_TYPE_16X16; |
| 3979 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
| 3980 |
s->mv[0][0][0] = 0; |
| 3981 |
s->mv[0][0][1] = 0; |
| 3982 |
s->mb_skipped = !(s->obmc | s->loop_filter); |
| 3983 |
goto end;
|
| 3984 |
} |
| 3985 |
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
|
| 3986 |
//fprintf(stderr, "\tCBPC: %d", cbpc);
|
| 3987 |
if (cbpc < 0){ |
| 3988 |
av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 3989 |
return -1; |
| 3990 |
} |
| 3991 |
}while(cbpc == 20); |
| 3992 |
|
| 3993 |
s->dsp.clear_blocks(s->block[0]);
|
| 3994 |
|
| 3995 |
dquant = cbpc & 8;
|
| 3996 |
s->mb_intra = ((cbpc & 4) != 0); |
| 3997 |
if (s->mb_intra) goto intra; |
| 3998 |
|
| 3999 |
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
|
| 4000 |
|
| 4001 |
if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
| 4002 |
cbpy ^= 0xF;
|
| 4003 |
|
| 4004 |
cbp = (cbpc & 3) | (cbpy << 2); |
| 4005 |
if (dquant) {
|
| 4006 |
h263_decode_dquant(s); |
| 4007 |
} |
| 4008 |
|
| 4009 |
s->mv_dir = MV_DIR_FORWARD; |
| 4010 |
if ((cbpc & 16) == 0) { |
| 4011 |
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
| 4012 |
/* 16x16 motion prediction */
|
| 4013 |
s->mv_type = MV_TYPE_16X16; |
| 4014 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 4015 |
if (s->umvplus)
|
| 4016 |
mx = h263p_decode_umotion(s, pred_x); |
| 4017 |
else
|
| 4018 |
mx = h263_decode_motion(s, pred_x, 1);
|
| 4019 |
|
| 4020 |
if (mx >= 0xffff) |
| 4021 |
return -1; |
| 4022 |
|
| 4023 |
if (s->umvplus)
|
| 4024 |
my = h263p_decode_umotion(s, pred_y); |
| 4025 |
else
|
| 4026 |
my = h263_decode_motion(s, pred_y, 1);
|
| 4027 |
|
| 4028 |
if (my >= 0xffff) |
| 4029 |
return -1; |
| 4030 |
s->mv[0][0][0] = mx; |
| 4031 |
s->mv[0][0][1] = my; |
| 4032 |
|
| 4033 |
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
| 4034 |
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
|
| 4035 |
} else {
|
| 4036 |
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
| 4037 |
s->mv_type = MV_TYPE_8X8; |
| 4038 |
for(i=0;i<4;i++) { |
| 4039 |
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
|
| 4040 |
if (s->umvplus)
|
| 4041 |
mx = h263p_decode_umotion(s, pred_x); |
| 4042 |
else
|
| 4043 |
mx = h263_decode_motion(s, pred_x, 1);
|
| 4044 |
if (mx >= 0xffff) |
| 4045 |
return -1; |
| 4046 |
|
| 4047 |
if (s->umvplus)
|
| 4048 |
my = h263p_decode_umotion(s, pred_y); |
| 4049 |
else
|
| 4050 |
my = h263_decode_motion(s, pred_y, 1);
|
| 4051 |
if (my >= 0xffff) |
| 4052 |
return -1; |
| 4053 |
s->mv[0][i][0] = mx; |
| 4054 |
s->mv[0][i][1] = my; |
| 4055 |
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
| 4056 |
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
|
| 4057 |
mot_val[0] = mx;
|
| 4058 |
mot_val[1] = my;
|
| 4059 |
} |
| 4060 |
} |
| 4061 |
|
| 4062 |
/* decode each block */
|
| 4063 |
for (i = 0; i < 6; i++) { |
| 4064 |
if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
| 4065 |
return -1; |
| 4066 |
cbp+=cbp; |
| 4067 |
} |
| 4068 |
|
| 4069 |
if(s->obmc){
|
| 4070 |
if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1) |
| 4071 |
preview_obmc(s); |
| 4072 |
} |
| 4073 |
} else if(s->pict_type==B_TYPE) { |
| 4074 |
int mb_type;
|
| 4075 |
const int stride= s->b8_stride; |
| 4076 |
int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; |
| 4077 |
int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; |
| 4078 |
// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
|
| 4079 |
|
| 4080 |
//FIXME ugly
|
| 4081 |
mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= |
| 4082 |
mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= |
| 4083 |
mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= |
| 4084 |
mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; |
| 4085 |
|
| 4086 |
do{
|
| 4087 |
mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
|
| 4088 |
if (mb_type < 0){ |
| 4089 |
av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 4090 |
return -1; |
| 4091 |
} |
| 4092 |
|
| 4093 |
mb_type= h263_mb_type_b_map[ mb_type ]; |
| 4094 |
}while(!mb_type);
|
| 4095 |
|
| 4096 |
s->mb_intra = IS_INTRA(mb_type); |
| 4097 |
if(HAS_CBP(mb_type)){
|
| 4098 |
s->dsp.clear_blocks(s->block[0]);
|
| 4099 |
cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
|
| 4100 |
if(s->mb_intra){
|
| 4101 |
dquant = IS_QUANT(mb_type); |
| 4102 |
goto intra;
|
| 4103 |
} |
| 4104 |
|
| 4105 |
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
|
| 4106 |
|
| 4107 |
if (cbpy < 0){ |
| 4108 |
av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 4109 |
return -1; |
| 4110 |
} |
| 4111 |
|
| 4112 |
if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
| 4113 |
cbpy ^= 0xF;
|
| 4114 |
|
| 4115 |
cbp = (cbpc & 3) | (cbpy << 2); |
| 4116 |
}else
|
| 4117 |
cbp=0;
|
| 4118 |
|
| 4119 |
assert(!s->mb_intra); |
| 4120 |
|
| 4121 |
if(IS_QUANT(mb_type)){
|
| 4122 |
h263_decode_dquant(s); |
| 4123 |
} |
| 4124 |
|
| 4125 |
if(IS_DIRECT(mb_type)){
|
| 4126 |
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
| 4127 |
mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); |
| 4128 |
}else{
|
| 4129 |
s->mv_dir = 0;
|
| 4130 |
s->mv_type= MV_TYPE_16X16; |
| 4131 |
//FIXME UMV
|
| 4132 |
|
| 4133 |
if(USES_LIST(mb_type, 0)){ |
| 4134 |
int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); |
| 4135 |
s->mv_dir = MV_DIR_FORWARD; |
| 4136 |
|
| 4137 |
mx = h263_decode_motion(s, mx, 1);
|
| 4138 |
my = h263_decode_motion(s, my, 1);
|
| 4139 |
|
| 4140 |
s->mv[0][0][0] = mx; |
| 4141 |
s->mv[0][0][1] = my; |
| 4142 |
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
| 4143 |
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; |
| 4144 |
} |
| 4145 |
|
| 4146 |
if(USES_LIST(mb_type, 1)){ |
| 4147 |
int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); |
| 4148 |
s->mv_dir |= MV_DIR_BACKWARD; |
| 4149 |
|
| 4150 |
mx = h263_decode_motion(s, mx, 1);
|
| 4151 |
my = h263_decode_motion(s, my, 1);
|
| 4152 |
|
| 4153 |
s->mv[1][0][0] = mx; |
| 4154 |
s->mv[1][0][1] = my; |
| 4155 |
mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
| 4156 |
mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; |
| 4157 |
} |
| 4158 |
} |
| 4159 |
|
| 4160 |
s->current_picture.mb_type[xy]= mb_type; |
| 4161 |
|
| 4162 |
/* decode each block */
|
| 4163 |
for (i = 0; i < 6; i++) { |
| 4164 |
if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
| 4165 |
return -1; |
| 4166 |
cbp+=cbp; |
| 4167 |
} |
| 4168 |
} else { /* I-Frame */ |
| 4169 |
do{
|
| 4170 |
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
|
| 4171 |
if (cbpc < 0){ |
| 4172 |
av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 4173 |
return -1; |
| 4174 |
} |
| 4175 |
}while(cbpc == 8); |
| 4176 |
|
| 4177 |
s->dsp.clear_blocks(s->block[0]);
|
| 4178 |
|
| 4179 |
dquant = cbpc & 4;
|
| 4180 |
s->mb_intra = 1;
|
| 4181 |
intra:
|
| 4182 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
| 4183 |
if (s->h263_aic) {
|
| 4184 |
s->ac_pred = get_bits1(&s->gb); |
| 4185 |
if(s->ac_pred){
|
| 4186 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
| 4187 |
|
| 4188 |
s->h263_aic_dir = get_bits1(&s->gb); |
| 4189 |
} |
| 4190 |
}else
|
| 4191 |
s->ac_pred = 0;
|
| 4192 |
|
| 4193 |
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
|
| 4194 |
if(cbpy<0){ |
| 4195 |
av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 4196 |
return -1; |
| 4197 |
} |
| 4198 |
cbp = (cbpc & 3) | (cbpy << 2); |
| 4199 |
if (dquant) {
|
| 4200 |
h263_decode_dquant(s); |
| 4201 |
} |
| 4202 |
|
| 4203 |
/* decode each block */
|
| 4204 |
for (i = 0; i < 6; i++) { |
| 4205 |
if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
| 4206 |
return -1; |
| 4207 |
cbp+=cbp; |
| 4208 |
} |
| 4209 |
} |
| 4210 |
end:
|
| 4211 |
|
| 4212 |
/* per-MB end of slice check */
|
| 4213 |
{
|
| 4214 |
int v= show_bits(&s->gb, 16); |
| 4215 |
|
| 4216 |
if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ |
| 4217 |
v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
|
| 4218 |
} |
| 4219 |
|
| 4220 |
if(v==0) |
| 4221 |
return SLICE_END;
|
| 4222 |
} |
| 4223 |
|
| 4224 |
return SLICE_OK;
|
| 4225 |
} |
| 4226 |
|
| 4227 |
int ff_mpeg4_decode_mb(MpegEncContext *s,
|
| 4228 |
DCTELEM block[6][64]) |
| 4229 |
{
|
| 4230 |
int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
|
| 4231 |
int16_t *mot_val; |
| 4232 |
static int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
| 4233 |
const int xy= s->mb_x + s->mb_y * s->mb_stride; |
| 4234 |
|
| 4235 |
assert(s->h263_pred); |
| 4236 |
|
| 4237 |
if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
|
| 4238 |
do{
|
| 4239 |
if (get_bits1(&s->gb)) {
|
| 4240 |
/* skip mb */
|
| 4241 |
s->mb_intra = 0;
|
| 4242 |
for(i=0;i<6;i++) |
| 4243 |
s->block_last_index[i] = -1;
|
| 4244 |
s->mv_dir = MV_DIR_FORWARD; |
| 4245 |
s->mv_type = MV_TYPE_16X16; |
| 4246 |
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
|
| 4247 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
| 4248 |
s->mcsel=1;
|
| 4249 |
s->mv[0][0][0]= get_amv(s, 0); |
| 4250 |
s->mv[0][0][1]= get_amv(s, 1); |
| 4251 |
|
| 4252 |
s->mb_skipped = 0;
|
| 4253 |
}else{
|
| 4254 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
| 4255 |
s->mcsel=0;
|
| 4256 |
s->mv[0][0][0] = 0; |
| 4257 |
s->mv[0][0][1] = 0; |
| 4258 |
s->mb_skipped = 1;
|
| 4259 |
} |
| 4260 |
goto end;
|
| 4261 |
} |
| 4262 |
cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
|
| 4263 |
//fprintf(stderr, "\tCBPC: %d", cbpc);
|
| 4264 |
if (cbpc < 0){ |
| 4265 |
av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 4266 |
return -1; |
| 4267 |
} |
| 4268 |
}while(cbpc == 20); |
| 4269 |
|
| 4270 |
s->dsp.clear_blocks(s->block[0]);
|
| 4271 |
dquant = cbpc & 8;
|
| 4272 |
s->mb_intra = ((cbpc & 4) != 0); |
| 4273 |
if (s->mb_intra) goto intra; |
| 4274 |
|
| 4275 |
if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
| 4276 |
s->mcsel= get_bits1(&s->gb); |
| 4277 |
else s->mcsel= 0; |
| 4278 |
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; |
| 4279 |
|
| 4280 |
cbp = (cbpc & 3) | (cbpy << 2); |
| 4281 |
if (dquant) {
|
| 4282 |
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
|
| 4283 |
} |
| 4284 |
if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
|
| 4285 |
s->interlaced_dct= get_bits1(&s->gb); |
| 4286 |
|
| 4287 |
s->mv_dir = MV_DIR_FORWARD; |
| 4288 |
if ((cbpc & 16) == 0) { |
| 4289 |
if(s->mcsel){
|
| 4290 |
s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
| 4291 |
/* 16x16 global motion prediction */
|
| 4292 |
s->mv_type = MV_TYPE_16X16; |
| 4293 |
mx= get_amv(s, 0);
|
| 4294 |
my= get_amv(s, 1);
|
| 4295 |
s->mv[0][0][0] = mx; |
| 4296 |
s->mv[0][0][1] = my; |
| 4297 |
}else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
| 4298 |
s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; |
| 4299 |
/* 16x8 field motion prediction */
|
| 4300 |
s->mv_type= MV_TYPE_FIELD; |
| 4301 |
|
| 4302 |
s->field_select[0][0]= get_bits1(&s->gb); |
| 4303 |
s->field_select[0][1]= get_bits1(&s->gb); |
| 4304 |
|
| 4305 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 4306 |
|
| 4307 |
for(i=0; i<2; i++){ |
| 4308 |
mx = h263_decode_motion(s, pred_x, s->f_code); |
| 4309 |
if (mx >= 0xffff) |
| 4310 |
return -1; |
| 4311 |
|
| 4312 |
my = h263_decode_motion(s, pred_y/2, s->f_code);
|
| 4313 |
if (my >= 0xffff) |
| 4314 |
return -1; |
| 4315 |
|
| 4316 |
s->mv[0][i][0] = mx; |
| 4317 |
s->mv[0][i][1] = my; |
| 4318 |
} |
| 4319 |
}else{
|
| 4320 |
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
| 4321 |
/* 16x16 motion prediction */
|
| 4322 |
s->mv_type = MV_TYPE_16X16; |
| 4323 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
| 4324 |
mx = h263_decode_motion(s, pred_x, s->f_code); |
| 4325 |
|
| 4326 |
if (mx >= 0xffff) |
| 4327 |
return -1; |
| 4328 |
|
| 4329 |
my = h263_decode_motion(s, pred_y, s->f_code); |
| 4330 |
|
| 4331 |
if (my >= 0xffff) |
| 4332 |
return -1; |
| 4333 |
s->mv[0][0][0] = mx; |
| 4334 |
s->mv[0][0][1] = my; |
| 4335 |
} |
| 4336 |
} else {
|
| 4337 |
s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
| 4338 |
s->mv_type = MV_TYPE_8X8; |
| 4339 |
for(i=0;i<4;i++) { |
| 4340 |
mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
|
| 4341 |
mx = h263_decode_motion(s, pred_x, s->f_code); |
| 4342 |
if (mx >= 0xffff) |
| 4343 |
return -1; |
| 4344 |
|
| 4345 |
my = h263_decode_motion(s, pred_y, s->f_code); |
| 4346 |
if (my >= 0xffff) |
| 4347 |
return -1; |
| 4348 |
s->mv[0][i][0] = mx; |
| 4349 |
s->mv[0][i][1] = my; |
| 4350 |
mot_val[0] = mx;
|
| 4351 |
mot_val[1] = my;
|
| 4352 |
} |
| 4353 |
} |
| 4354 |
} else if(s->pict_type==B_TYPE) { |
| 4355 |
int modb1; // first bit of modb |
| 4356 |
int modb2; // second bit of modb |
| 4357 |
int mb_type;
|
| 4358 |
|
| 4359 |
s->mb_intra = 0; //B-frames never contain intra blocks |
| 4360 |
s->mcsel=0; // ... true gmc blocks |
| 4361 |
|
| 4362 |
if(s->mb_x==0){ |
| 4363 |
for(i=0; i<2; i++){ |
| 4364 |
s->last_mv[i][0][0]= |
| 4365 |
s->last_mv[i][0][1]= |
| 4366 |
s->last_mv[i][1][0]= |
| 4367 |
s->last_mv[i][1][1]= 0; |
| 4368 |
} |
| 4369 |
} |
| 4370 |
|
| 4371 |
/* if we skipped it in the future P Frame than skip it now too */
|
| 4372 |
s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
|
| 4373 |
|
| 4374 |
if(s->mb_skipped){
|
| 4375 |
/* skip mb */
|
| 4376 |
for(i=0;i<6;i++) |
| 4377 |
s->block_last_index[i] = -1;
|
| 4378 |
|
| 4379 |
s->mv_dir = MV_DIR_FORWARD; |
| 4380 |
s->mv_type = MV_TYPE_16X16; |
| 4381 |
s->mv[0][0][0] = 0; |
| 4382 |
s->mv[0][0][1] = 0; |
| 4383 |
s->mv[1][0][0] = 0; |
| 4384 |
s->mv[1][0][1] = 0; |
| 4385 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
| 4386 |
goto end;
|
| 4387 |
} |
| 4388 |
|
| 4389 |
modb1= get_bits1(&s->gb); |
| 4390 |
if(modb1){
|
| 4391 |
mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
|
| 4392 |
cbp=0;
|
| 4393 |
}else{
|
| 4394 |
modb2= get_bits1(&s->gb); |
| 4395 |
mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
|
| 4396 |
if(mb_type<0){ |
| 4397 |
av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
|
| 4398 |
return -1; |
| 4399 |
} |
| 4400 |
mb_type= mb_type_b_map[ mb_type ]; |
| 4401 |
if(modb2) cbp= 0; |
| 4402 |
else{
|
| 4403 |
s->dsp.clear_blocks(s->block[0]);
|
| 4404 |
cbp= get_bits(&s->gb, 6);
|
| 4405 |
} |
| 4406 |
|
| 4407 |
if ((!IS_DIRECT(mb_type)) && cbp) {
|
| 4408 |
if(get_bits1(&s->gb)){
|
| 4409 |
ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); |
| 4410 |
} |
| 4411 |
} |
| 4412 |
|
| 4413 |
if(!s->progressive_sequence){
|
| 4414 |
if(cbp)
|
| 4415 |
s->interlaced_dct= get_bits1(&s->gb); |
| 4416 |
|
| 4417 |
if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
|
| 4418 |
mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; |
| 4419 |
mb_type &= ~MB_TYPE_16x16; |
| 4420 |
|
| 4421 |
if(USES_LIST(mb_type, 0)){ |
| 4422 |
s->field_select[0][0]= get_bits1(&s->gb); |
| 4423 |
s->field_select[0][1]= get_bits1(&s->gb); |
| 4424 |
} |
| 4425 |
if(USES_LIST(mb_type, 1)){ |
| 4426 |
s->field_select[1][0]= get_bits1(&s->gb); |
| 4427 |
s->field_select[1][1]= get_bits1(&s->gb); |
| 4428 |
} |
| 4429 |
} |
| 4430 |
} |
| 4431 |
|
| 4432 |
s->mv_dir = 0;
|
| 4433 |
if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
| 4434 |
s->mv_type= MV_TYPE_16X16; |
| 4435 |
|
| 4436 |
if(USES_LIST(mb_type, 0)){ |
| 4437 |
s->mv_dir = MV_DIR_FORWARD; |
| 4438 |
|
| 4439 |
mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); |
| 4440 |
my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); |
| 4441 |
s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; |
| 4442 |
s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; |
| 4443 |
} |
| 4444 |
|
| 4445 |
if(USES_LIST(mb_type, 1)){ |
| 4446 |
s->mv_dir |= MV_DIR_BACKWARD; |
| 4447 |
|
| 4448 |
mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); |
| 4449 |
my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); |
| 4450 |
s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; |
| 4451 |
s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; |
| 4452 |
} |
| 4453 |
}else if(!IS_DIRECT(mb_type)){ |
| 4454 |
s->mv_type= MV_TYPE_FIELD; |
| 4455 |
|
| 4456 |
if(USES_LIST(mb_type, 0)){ |
| 4457 |
s->mv_dir = MV_DIR_FORWARD; |
| 4458 |
|
| 4459 |
for(i=0; i<2; i++){ |
| 4460 |
mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); |
| 4461 |
my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); |
| 4462 |
s->last_mv[0][i][0]= s->mv[0][i][0] = mx; |
| 4463 |
s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; |
| 4464 |
} |
| 4465 |
} |
| 4466 |
|
| 4467 |
if(USES_LIST(mb_type, 1)){ |
| 4468 |
s->mv_dir |= MV_DIR_BACKWARD; |
| 4469 |
|
| 4470 |
for(i=0; i<2; i++){ |
| 4471 |
mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); |
| 4472 |
my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); |
| 4473 |
s->last_mv[1][i][0]= s->mv[1][i][0] = mx; |
| 4474 |
s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; |
| 4475 |
} |
| 4476 |
} |
| 4477 |
} |
| 4478 |
} |
| 4479 |
|
| 4480 |
if(IS_DIRECT(mb_type)){
|
| 4481 |
if(IS_SKIP(mb_type))
|
| 4482 |
mx=my=0;
|
| 4483 |
else{
|
| 4484 |
mx = h263_decode_motion(s, 0, 1); |
| 4485 |
my = h263_decode_motion(s, 0, 1); |
| 4486 |
} |
| 4487 |
|
| 4488 |
s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
| 4489 |
mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
| 4490 |
} |
| 4491 |
s->current_picture.mb_type[xy]= mb_type; |
| 4492 |
} else { /* I-Frame */ |
| 4493 |
do{
|
| 4494 |
cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
|
| 4495 |
if (cbpc < 0){ |
| 4496 |
av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 4497 |
return -1; |
| 4498 |
} |
| 4499 |
}while(cbpc == 8); |
| 4500 |
|
| 4501 |
dquant = cbpc & 4;
|
| 4502 |
s->mb_intra = 1;
|
| 4503 |
intra:
|
| 4504 |
s->ac_pred = get_bits1(&s->gb); |
| 4505 |
if(s->ac_pred)
|
| 4506 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
| 4507 |
else
|
| 4508 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
| 4509 |
|
| 4510 |
cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
|
| 4511 |
if(cbpy<0){ |
| 4512 |
av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
|
| 4513 |
return -1; |
| 4514 |
} |
| 4515 |
cbp = (cbpc & 3) | (cbpy << 2); |
| 4516 |
|
| 4517 |
s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; |
| 4518 |
|
| 4519 |
if (dquant) {
|
| 4520 |
ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
|
| 4521 |
} |
| 4522 |
|
| 4523 |
if(!s->progressive_sequence)
|
| 4524 |
s->interlaced_dct= get_bits1(&s->gb); |
| 4525 |
|
| 4526 |
s->dsp.clear_blocks(s->block[0]);
|
| 4527 |
/* decode each block */
|
| 4528 |
for (i = 0; i < 6; i++) { |
| 4529 |
if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) |
| 4530 |
return -1; |
| 4531 |
cbp+=cbp; |
| 4532 |
} |
| 4533 |
goto end;
|
| 4534 |
} |
| 4535 |
|
| 4536 |
/* decode each block */
|
| 4537 |
for (i = 0; i < 6; i++) { |
| 4538 |
if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) |
| 4539 |
return -1; |
| 4540 |
cbp+=cbp; |
| 4541 |
} |
| 4542 |
end:
|
| 4543 |
|
| 4544 |
/* per-MB end of slice check */
|
| 4545 |
if(s->codec_id==CODEC_ID_MPEG4){
|
| 4546 |
if(mpeg4_is_resync(s)){
|
| 4547 |
const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
| 4548 |
if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
|
| 4549 |
return SLICE_OK;
|
| 4550 |
return SLICE_END;
|
| 4551 |
} |
| 4552 |
} |
| 4553 |
|
| 4554 |
return SLICE_OK;
|
| 4555 |
} |
| 4556 |
|
| 4557 |
static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
| 4558 |
{
|
| 4559 |
int code, val, sign, shift, l;
|
| 4560 |
code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
|
| 4561 |
|
| 4562 |
if (code == 0) |
| 4563 |
return pred;
|
| 4564 |
if (code < 0) |
| 4565 |
return 0xffff; |
| 4566 |
|
| 4567 |
sign = get_bits1(&s->gb); |
| 4568 |
shift = f_code - 1;
|
| 4569 |
val = code; |
| 4570 |
if (shift) {
|
| 4571 |
val = (val - 1) << shift;
|
| 4572 |
val |= get_bits(&s->gb, shift); |
| 4573 |
val++; |
| 4574 |
} |
| 4575 |
if (sign)
|
| 4576 |
val = -val; |
| 4577 |
val += pred; |
| 4578 |
|
| 4579 |
/* modulo decoding */
|
| 4580 |
if (!s->h263_long_vectors) {
|
| 4581 |
l = INT_BIT - 5 - f_code;
|
| 4582 |
val = (val<<l)>>l; |
| 4583 |
} else {
|
| 4584 |
/* horrible h263 long vector mode */
|
| 4585 |
if (pred < -31 && val < -63) |
| 4586 |
val += 64;
|
| 4587 |
if (pred > 32 && val > 63) |
| 4588 |
val -= 64;
|
| 4589 |
|
| 4590 |
} |
| 4591 |
return val;
|
| 4592 |
} |
| 4593 |
|
| 4594 |
/* Decodes RVLC of H.263+ UMV */
|
| 4595 |
static int h263p_decode_umotion(MpegEncContext * s, int pred) |
| 4596 |
{
|
| 4597 |
int code = 0, sign; |
| 4598 |
|
| 4599 |
if (get_bits1(&s->gb)) /* Motion difference = 0 */ |
| 4600 |
return pred;
|
| 4601 |
|
| 4602 |
code = 2 + get_bits1(&s->gb);
|
| 4603 |
|
| 4604 |
while (get_bits1(&s->gb))
|
| 4605 |
{
|
| 4606 |
code <<= 1;
|
| 4607 |
code += get_bits1(&s->gb); |
| 4608 |
} |
| 4609 |
sign = code & 1;
|
| 4610 |
code >>= 1;
|
| 4611 |
|
| 4612 |
code = (sign) ? (pred - code) : (pred + code); |
| 4613 |
#ifdef DEBUG
|
| 4614 |
av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
|
| 4615 |
#endif
|
| 4616 |
return code;
|
| 4617 |
|
| 4618 |
} |
| 4619 |
|
| 4620 |
static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
| 4621 |
int n, int coded) |
| 4622 |
{
|
| 4623 |
int code, level, i, j, last, run;
|
| 4624 |
RLTable *rl = &rl_inter; |
| 4625 |
const uint8_t *scan_table;
|
| 4626 |
GetBitContext gb= s->gb; |
| 4627 |
|
| 4628 |
scan_table = s->intra_scantable.permutated; |
| 4629 |
if (s->h263_aic && s->mb_intra) {
|
| 4630 |
rl = &rl_intra_aic; |
| 4631 |
i = 0;
|
| 4632 |
if (s->ac_pred) {
|
| 4633 |
if (s->h263_aic_dir)
|
| 4634 |
scan_table = s->intra_v_scantable.permutated; /* left */
|
| 4635 |
else
|
| 4636 |
scan_table = s->intra_h_scantable.permutated; /* top */
|
| 4637 |
} |
| 4638 |
} else if (s->mb_intra) { |
| 4639 |
/* DC coef */
|
| 4640 |
if(s->codec_id == CODEC_ID_RV10){
|
| 4641 |
#ifdef CONFIG_RV10_DECODER
|
| 4642 |
if (s->rv10_version == 3 && s->pict_type == I_TYPE) { |
| 4643 |
int component, diff;
|
| 4644 |
component = (n <= 3 ? 0 : n - 4 + 1); |
| 4645 |
level = s->last_dc[component]; |
| 4646 |
if (s->rv10_first_dc_coded[component]) {
|
| 4647 |
diff = rv_decode_dc(s, n); |
| 4648 |
if (diff == 0xffff) |
| 4649 |
return -1; |
| 4650 |
level += diff; |
| 4651 |
level = level & 0xff; /* handle wrap round */ |
| 4652 |
s->last_dc[component] = level; |
| 4653 |
} else {
|
| 4654 |
s->rv10_first_dc_coded[component] = 1;
|
| 4655 |
} |
| 4656 |
} else {
|
| 4657 |
level = get_bits(&s->gb, 8);
|
| 4658 |
if (level == 255) |
| 4659 |
level = 128;
|
| 4660 |
} |
| 4661 |
#endif
|
| 4662 |
}else{
|
| 4663 |
level = get_bits(&s->gb, 8);
|
| 4664 |
if((level&0x7F) == 0){ |
| 4665 |
av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
|
| 4666 |
if(s->error_resilience >= FF_ER_COMPLIANT)
|
| 4667 |
return -1; |
| 4668 |
} |
| 4669 |
if (level == 255) |
| 4670 |
level = 128;
|
| 4671 |
} |
| 4672 |
block[0] = level;
|
| 4673 |
i = 1;
|
| 4674 |
} else {
|
| 4675 |
i = 0;
|
| 4676 |
} |
| 4677 |
if (!coded) {
|
| 4678 |
if (s->mb_intra && s->h263_aic)
|
| 4679 |
goto not_coded;
|
| 4680 |
s->block_last_index[n] = i - 1;
|
| 4681 |
return 0; |
| 4682 |
} |
| 4683 |
retry:
|
| 4684 |
for(;;) {
|
| 4685 |
code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
|
| 4686 |
if (code < 0){ |
| 4687 |
av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
|
| 4688 |
return -1; |
| 4689 |
} |
| 4690 |
if (code == rl->n) {
|
| 4691 |
/* escape */
|
| 4692 |
if (s->h263_flv > 1) { |
| 4693 |
int is11 = get_bits1(&s->gb);
|
| 4694 |
last = get_bits1(&s->gb); |
| 4695 |
run = get_bits(&s->gb, 6);
|
| 4696 |
if(is11){
|
| 4697 |
level = get_sbits(&s->gb, 11);
|
| 4698 |
} else {
|
| 4699 |
level = get_sbits(&s->gb, 7);
|
| 4700 |
} |
| 4701 |
} else {
|
| 4702 |
last = get_bits1(&s->gb); |
| 4703 |
run = get_bits(&s->gb, 6);
|
| 4704 |
level = (int8_t)get_bits(&s->gb, 8);
|
| 4705 |
if(level == -128){ |
| 4706 |
if (s->codec_id == CODEC_ID_RV10) {
|
| 4707 |
/* XXX: should patch encoder too */
|
| 4708 |
level = get_sbits(&s->gb, 12);
|
| 4709 |
}else{
|
| 4710 |
level = get_bits(&s->gb, 5);
|
| 4711 |
level |= get_sbits(&s->gb, 6)<<5; |
| 4712 |
} |
| 4713 |
} |
| 4714 |
} |
| 4715 |
} else {
|
| 4716 |
run = rl->table_run[code]; |
| 4717 |
level = rl->table_level[code]; |
| 4718 |
last = code >= rl->last; |
| 4719 |
if (get_bits1(&s->gb))
|
| 4720 |
level = -level; |
| 4721 |
} |
| 4722 |
i += run; |
| 4723 |
if (i >= 64){ |
| 4724 |
if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
|
| 4725 |
//looks like a hack but no, it's the way its supposed to work ...
|
| 4726 |
rl = &rl_intra_aic; |
| 4727 |
i = 0;
|
| 4728 |
s->gb= gb; |
| 4729 |
memset(block, 0, sizeof(DCTELEM)*64); |
| 4730 |
goto retry;
|
| 4731 |
} |
| 4732 |
av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
|
| 4733 |
return -1; |
| 4734 |
} |
| 4735 |
j = scan_table[i]; |
| 4736 |
block[j] = level; |
| 4737 |
if (last)
|
| 4738 |
break;
|
| 4739 |
i++; |
| 4740 |
} |
| 4741 |
not_coded:
|
| 4742 |
if (s->mb_intra && s->h263_aic) {
|
| 4743 |
h263_pred_acdc(s, block, n); |
| 4744 |
i = 63;
|
| 4745 |
} |
| 4746 |
s->block_last_index[n] = i; |
| 4747 |
return 0; |
| 4748 |
} |
| 4749 |
|
| 4750 |
/**
|
| 4751 |
* decodes the dc value.
|
| 4752 |
* @param n block index (0-3 are luma, 4-5 are chroma)
|
| 4753 |
* @param dir_ptr the prediction direction will be stored here
|
| 4754 |
* @return the quantized dc
|
| 4755 |
*/
|
| 4756 |
static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
| 4757 |
{
|
| 4758 |
int level, code;
|
| 4759 |
|
| 4760 |
if (n < 4) |
| 4761 |
code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
|
| 4762 |
else
|
| 4763 |
code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
|
| 4764 |
if (code < 0 || code > 9 /* && s->nbit<9 */){ |
| 4765 |
av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
|
| 4766 |
return -1; |
| 4767 |
} |
| 4768 |
if (code == 0) { |
| 4769 |
level = 0;
|
| 4770 |
} else {
|
| 4771 |
if(IS_3IV1){
|
| 4772 |
if(code==1) |
| 4773 |
level= 2*get_bits1(&s->gb)-1; |
| 4774 |
else{
|
| 4775 |
if(get_bits1(&s->gb))
|
| 4776 |
level = get_bits(&s->gb, code-1) + (1<<(code-1)); |
| 4777 |
else
|
| 4778 |
level = -get_bits(&s->gb, code-1) - (1<<(code-1)); |
| 4779 |
} |
| 4780 |
}else{
|
| 4781 |
level = get_xbits(&s->gb, code); |
| 4782 |
} |
| 4783 |
|
| 4784 |
if (code > 8){ |
| 4785 |
if(get_bits1(&s->gb)==0){ /* marker */ |
| 4786 |
if(s->error_resilience>=2){ |
| 4787 |
av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
|
| 4788 |
return -1; |
| 4789 |
} |
| 4790 |
|