ffmpeg / libavcodec / mpeg12enc.c @ d36beb3f
History | View | Annotate | Download (34.4 KB)
| 1 |
/*
|
|---|---|
| 2 |
* MPEG1/2 encoder
|
| 3 |
* Copyright (c) 2000,2001 Fabrice Bellard
|
| 4 |
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
|
| 5 |
*
|
| 6 |
* This file is part of FFmpeg.
|
| 7 |
*
|
| 8 |
* FFmpeg is free software; you can redistribute it and/or
|
| 9 |
* modify it under the terms of the GNU Lesser General Public
|
| 10 |
* License as published by the Free Software Foundation; either
|
| 11 |
* version 2.1 of the License, or (at your option) any later version.
|
| 12 |
*
|
| 13 |
* FFmpeg is distributed in the hope that it will be useful,
|
| 14 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
| 15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
| 16 |
* Lesser General Public License for more details.
|
| 17 |
*
|
| 18 |
* You should have received a copy of the GNU Lesser General Public
|
| 19 |
* License along with FFmpeg; if not, write to the Free Software
|
| 20 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
| 21 |
*/
|
| 22 |
|
| 23 |
/**
|
| 24 |
* @file
|
| 25 |
* MPEG1/2 encoder
|
| 26 |
*/
|
| 27 |
|
| 28 |
#include "avcodec.h" |
| 29 |
#include "dsputil.h" |
| 30 |
#include "mpegvideo.h" |
| 31 |
|
| 32 |
#include "mpeg12.h" |
| 33 |
#include "mpeg12data.h" |
| 34 |
#include "bytestream.h" |
| 35 |
|
| 36 |
|
| 37 |
static const uint8_t inv_non_linear_qscale[13] = { |
| 38 |
0, 2, 4, 6, 8, |
| 39 |
9,10,11,12,13,14,15,16, |
| 40 |
}; |
| 41 |
|
| 42 |
static const uint8_t svcd_scan_offset_placeholder[14] = { |
| 43 |
0x10, 0x0E, |
| 44 |
0x00, 0x80, 0x81, |
| 45 |
0x00, 0x80, 0x81, |
| 46 |
0xff, 0xff, 0xff, |
| 47 |
0xff, 0xff, 0xff, |
| 48 |
}; |
| 49 |
|
| 50 |
static void mpeg1_encode_block(MpegEncContext *s, |
| 51 |
DCTELEM *block, |
| 52 |
int component);
|
| 53 |
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added |
| 54 |
|
| 55 |
static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
| 56 |
static uint8_t fcode_tab[MAX_MV*2+1]; |
| 57 |
|
| 58 |
static uint8_t uni_mpeg1_ac_vlc_len [64*64*2]; |
| 59 |
static uint8_t uni_mpeg2_ac_vlc_len [64*64*2]; |
| 60 |
|
| 61 |
/* simple include everything table for dc, first byte is bits number next 3 are code*/
|
| 62 |
static uint32_t mpeg1_lum_dc_uni[512]; |
| 63 |
static uint32_t mpeg1_chr_dc_uni[512]; |
| 64 |
|
| 65 |
static uint8_t mpeg1_index_run[2][64]; |
| 66 |
static int8_t mpeg1_max_level[2][64]; |
| 67 |
|
| 68 |
static void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len){ |
| 69 |
int i;
|
| 70 |
|
| 71 |
for(i=0; i<128; i++){ |
| 72 |
int level= i-64; |
| 73 |
int run;
|
| 74 |
for(run=0; run<64; run++){ |
| 75 |
int len, bits, code;
|
| 76 |
|
| 77 |
int alevel= FFABS(level);
|
| 78 |
int sign= (level>>31)&1; |
| 79 |
|
| 80 |
if (alevel > rl->max_level[0][run]) |
| 81 |
code= 111; /*rl->n*/ |
| 82 |
else
|
| 83 |
code= rl->index_run[0][run] + alevel - 1; |
| 84 |
|
| 85 |
if (code < 111 /* rl->n */) { |
| 86 |
/* store the vlc & sign at once */
|
| 87 |
len= rl->table_vlc[code][1]+1; |
| 88 |
bits= (rl->table_vlc[code][0]<<1) + sign; |
| 89 |
} else {
|
| 90 |
len= rl->table_vlc[111/*rl->n*/][1]+6; |
| 91 |
bits= rl->table_vlc[111/*rl->n*/][0]<<6; |
| 92 |
|
| 93 |
bits|= run; |
| 94 |
if (alevel < 128) { |
| 95 |
bits<<=8; len+=8; |
| 96 |
bits|= level & 0xff;
|
| 97 |
} else {
|
| 98 |
bits<<=16; len+=16; |
| 99 |
bits|= level & 0xff;
|
| 100 |
if (level < 0) { |
| 101 |
bits|= 0x8001 + level + 255; |
| 102 |
} else {
|
| 103 |
bits|= level & 0xffff;
|
| 104 |
} |
| 105 |
} |
| 106 |
} |
| 107 |
|
| 108 |
uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len; |
| 109 |
} |
| 110 |
} |
| 111 |
} |
| 112 |
|
| 113 |
|
| 114 |
static int find_frame_rate_index(MpegEncContext *s){ |
| 115 |
int i;
|
| 116 |
int64_t dmin= INT64_MAX; |
| 117 |
int64_t d; |
| 118 |
|
| 119 |
for(i=1;i<14;i++) { |
| 120 |
int64_t n0= 1001LL/ff_frame_rate_tab[i].den*ff_frame_rate_tab[i].num*s->avctx->time_base.num;
|
| 121 |
int64_t n1= 1001LL*s->avctx->time_base.den;
|
| 122 |
if(s->avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL && i>=9) break; |
| 123 |
|
| 124 |
d = FFABS(n0 - n1); |
| 125 |
if(d < dmin){
|
| 126 |
dmin=d; |
| 127 |
s->frame_rate_index= i; |
| 128 |
} |
| 129 |
} |
| 130 |
if(dmin)
|
| 131 |
return -1; |
| 132 |
else
|
| 133 |
return 0; |
| 134 |
} |
| 135 |
|
| 136 |
static av_cold int encode_init(AVCodecContext *avctx) |
| 137 |
{
|
| 138 |
MpegEncContext *s = avctx->priv_data; |
| 139 |
|
| 140 |
if(MPV_encode_init(avctx) < 0) |
| 141 |
return -1; |
| 142 |
|
| 143 |
if(find_frame_rate_index(s) < 0){ |
| 144 |
if(s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
|
| 145 |
av_log(avctx, AV_LOG_ERROR, "MPEG1/2 does not support %d/%d fps\n", avctx->time_base.den, avctx->time_base.num);
|
| 146 |
return -1; |
| 147 |
}else{
|
| 148 |
av_log(avctx, AV_LOG_INFO, "MPEG1/2 does not support %d/%d fps, there may be AV sync issues\n", avctx->time_base.den, avctx->time_base.num);
|
| 149 |
} |
| 150 |
} |
| 151 |
|
| 152 |
if(avctx->profile == FF_PROFILE_UNKNOWN){
|
| 153 |
if(avctx->level != FF_LEVEL_UNKNOWN){
|
| 154 |
av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
|
| 155 |
return -1; |
| 156 |
} |
| 157 |
avctx->profile = s->chroma_format == CHROMA_420 ? 4 : 0; /* Main or 4:2:2 */ |
| 158 |
} |
| 159 |
|
| 160 |
if(avctx->level == FF_LEVEL_UNKNOWN){
|
| 161 |
if(avctx->profile == 0){ /* 4:2:2 */ |
| 162 |
if(avctx->width <= 720 && avctx->height <= 608) avctx->level = 5; /* Main */ |
| 163 |
else avctx->level = 2; /* High */ |
| 164 |
}else{
|
| 165 |
if(avctx->profile != 1 && s->chroma_format != CHROMA_420){ |
| 166 |
av_log(avctx, AV_LOG_ERROR, "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
|
| 167 |
return -1; |
| 168 |
} |
| 169 |
if(avctx->width <= 720 && avctx->height <= 576) avctx->level = 8; /* Main */ |
| 170 |
else if(avctx->width <= 1440) avctx->level = 6; /* High 1440 */ |
| 171 |
else avctx->level = 4; /* High */ |
| 172 |
} |
| 173 |
} |
| 174 |
|
| 175 |
if((avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) && s->frame_rate_index != 4){ |
| 176 |
av_log(avctx, AV_LOG_ERROR, "Drop frame time code only allowed with 1001/30000 fps\n");
|
| 177 |
return -1; |
| 178 |
} |
| 179 |
|
| 180 |
return 0; |
| 181 |
} |
| 182 |
|
| 183 |
static void put_header(MpegEncContext *s, int header) |
| 184 |
{
|
| 185 |
align_put_bits(&s->pb); |
| 186 |
put_bits(&s->pb, 16, header>>16); |
| 187 |
put_sbits(&s->pb, 16, header);
|
| 188 |
} |
| 189 |
|
| 190 |
/* put sequence header if needed */
|
| 191 |
static void mpeg1_encode_sequence_header(MpegEncContext *s) |
| 192 |
{
|
| 193 |
unsigned int vbv_buffer_size; |
| 194 |
unsigned int fps, v; |
| 195 |
int i;
|
| 196 |
uint64_t time_code; |
| 197 |
float best_aspect_error= 1E10; |
| 198 |
float aspect_ratio= av_q2d(s->avctx->sample_aspect_ratio);
|
| 199 |
int constraint_parameter_flag;
|
| 200 |
|
| 201 |
if(aspect_ratio==0.0) aspect_ratio= 1.0; //pixel aspect 1:1 (VGA) |
| 202 |
|
| 203 |
if (s->current_picture.key_frame) {
|
| 204 |
AVRational framerate= ff_frame_rate_tab[s->frame_rate_index]; |
| 205 |
|
| 206 |
/* mpeg1 header repeated every gop */
|
| 207 |
put_header(s, SEQ_START_CODE); |
| 208 |
|
| 209 |
put_sbits(&s->pb, 12, s->width );
|
| 210 |
put_sbits(&s->pb, 12, s->height);
|
| 211 |
|
| 212 |
for(i=1; i<15; i++){ |
| 213 |
float error= aspect_ratio;
|
| 214 |
if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1) |
| 215 |
error-= 1.0/ff_mpeg1_aspect[i]; |
| 216 |
else
|
| 217 |
error-= av_q2d(ff_mpeg2_aspect[i])*s->height/s->width; |
| 218 |
|
| 219 |
error= FFABS(error); |
| 220 |
|
| 221 |
if(error < best_aspect_error){
|
| 222 |
best_aspect_error= error; |
| 223 |
s->aspect_ratio_info= i; |
| 224 |
} |
| 225 |
} |
| 226 |
|
| 227 |
put_bits(&s->pb, 4, s->aspect_ratio_info);
|
| 228 |
put_bits(&s->pb, 4, s->frame_rate_index);
|
| 229 |
|
| 230 |
if(s->avctx->rc_max_rate){
|
| 231 |
v = (s->avctx->rc_max_rate + 399) / 400; |
| 232 |
if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO) |
| 233 |
v = 0x3ffff;
|
| 234 |
}else{
|
| 235 |
v= 0x3FFFF;
|
| 236 |
} |
| 237 |
|
| 238 |
if(s->avctx->rc_buffer_size)
|
| 239 |
vbv_buffer_size = s->avctx->rc_buffer_size; |
| 240 |
else
|
| 241 |
/* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
|
| 242 |
vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024; |
| 243 |
vbv_buffer_size= (vbv_buffer_size + 16383) / 16384; |
| 244 |
|
| 245 |
put_sbits(&s->pb, 18, v);
|
| 246 |
put_bits(&s->pb, 1, 1); /* marker */ |
| 247 |
put_sbits(&s->pb, 10, vbv_buffer_size);
|
| 248 |
|
| 249 |
constraint_parameter_flag= |
| 250 |
s->width <= 768 && s->height <= 576 && |
| 251 |
s->mb_width * s->mb_height <= 396 &&
|
| 252 |
s->mb_width * s->mb_height * framerate.num <= framerate.den*396*25 && |
| 253 |
framerate.num <= framerate.den*30 &&
|
| 254 |
s->avctx->me_range && s->avctx->me_range < 128 &&
|
| 255 |
vbv_buffer_size <= 20 &&
|
| 256 |
v <= 1856000/400 && |
| 257 |
s->codec_id == CODEC_ID_MPEG1VIDEO; |
| 258 |
|
| 259 |
put_bits(&s->pb, 1, constraint_parameter_flag);
|
| 260 |
|
| 261 |
ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); |
| 262 |
ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); |
| 263 |
|
| 264 |
if(s->codec_id == CODEC_ID_MPEG2VIDEO){
|
| 265 |
put_header(s, EXT_START_CODE); |
| 266 |
put_bits(&s->pb, 4, 1); //seq ext |
| 267 |
|
| 268 |
put_bits(&s->pb, 1, s->avctx->profile == 0); //escx 1 for 4:2:2 profile */ |
| 269 |
|
| 270 |
put_bits(&s->pb, 3, s->avctx->profile); //profile |
| 271 |
put_bits(&s->pb, 4, s->avctx->level); //level |
| 272 |
|
| 273 |
put_bits(&s->pb, 1, s->progressive_sequence);
|
| 274 |
put_bits(&s->pb, 2, s->chroma_format);
|
| 275 |
put_bits(&s->pb, 2, s->width >>12); |
| 276 |
put_bits(&s->pb, 2, s->height>>12); |
| 277 |
put_bits(&s->pb, 12, v>>18); //bitrate ext |
| 278 |
put_bits(&s->pb, 1, 1); //marker |
| 279 |
put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext |
| 280 |
put_bits(&s->pb, 1, s->low_delay);
|
| 281 |
put_bits(&s->pb, 2, 0); // frame_rate_ext_n |
| 282 |
put_bits(&s->pb, 5, 0); // frame_rate_ext_d |
| 283 |
} |
| 284 |
|
| 285 |
put_header(s, GOP_START_CODE); |
| 286 |
put_bits(&s->pb, 1, !!(s->avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE)); /* drop frame flag */ |
| 287 |
/* time code : we must convert from the real frame rate to a
|
| 288 |
fake mpeg frame rate in case of low frame rate */
|
| 289 |
fps = (framerate.num + framerate.den/2)/ framerate.den;
|
| 290 |
time_code = s->current_picture_ptr->coded_picture_number + s->avctx->timecode_frame_start; |
| 291 |
|
| 292 |
s->gop_picture_number = s->current_picture_ptr->coded_picture_number; |
| 293 |
if (s->avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) {
|
| 294 |
/* only works for NTSC 29.97 */
|
| 295 |
int d = time_code / 17982; |
| 296 |
int m = time_code % 17982; |
| 297 |
//if (m < 2) m += 2; /* not needed since -2,-1 / 1798 in C returns 0 */
|
| 298 |
time_code += 18 * d + 2 * ((m - 2) / 1798); |
| 299 |
} |
| 300 |
put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24)); |
| 301 |
put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60)); |
| 302 |
put_bits(&s->pb, 1, 1); |
| 303 |
put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60)); |
| 304 |
put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
|
| 305 |
put_bits(&s->pb, 1, !!(s->flags & CODEC_FLAG_CLOSED_GOP));
|
| 306 |
put_bits(&s->pb, 1, 0); /* broken link */ |
| 307 |
} |
| 308 |
} |
| 309 |
|
| 310 |
static inline void encode_mb_skip_run(MpegEncContext *s, int run){ |
| 311 |
while (run >= 33) { |
| 312 |
put_bits(&s->pb, 11, 0x008); |
| 313 |
run -= 33;
|
| 314 |
} |
| 315 |
put_bits(&s->pb, ff_mpeg12_mbAddrIncrTable[run][1],
|
| 316 |
ff_mpeg12_mbAddrIncrTable[run][0]);
|
| 317 |
} |
| 318 |
|
| 319 |
static av_always_inline void put_qscale(MpegEncContext *s) |
| 320 |
{
|
| 321 |
if(s->q_scale_type){
|
| 322 |
assert(s->qscale>=1 && s->qscale <=12); |
| 323 |
put_bits(&s->pb, 5, inv_non_linear_qscale[s->qscale]);
|
| 324 |
}else{
|
| 325 |
put_bits(&s->pb, 5, s->qscale);
|
| 326 |
} |
| 327 |
} |
| 328 |
|
| 329 |
void ff_mpeg1_encode_slice_header(MpegEncContext *s){
|
| 330 |
if (s->height > 2800) { |
| 331 |
put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
|
| 332 |
put_bits(&s->pb, 3, s->mb_y >> 7); /* slice_vertical_position_extension */ |
| 333 |
} else {
|
| 334 |
put_header(s, SLICE_MIN_START_CODE + s->mb_y); |
| 335 |
} |
| 336 |
put_qscale(s); |
| 337 |
put_bits(&s->pb, 1, 0); /* slice extra information */ |
| 338 |
} |
| 339 |
|
| 340 |
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) |
| 341 |
{
|
| 342 |
mpeg1_encode_sequence_header(s); |
| 343 |
|
| 344 |
/* mpeg1 picture header */
|
| 345 |
put_header(s, PICTURE_START_CODE); |
| 346 |
/* temporal reference */
|
| 347 |
|
| 348 |
// RAL: s->picture_number instead of s->fake_picture_number
|
| 349 |
put_bits(&s->pb, 10, (s->picture_number -
|
| 350 |
s->gop_picture_number) & 0x3ff);
|
| 351 |
put_bits(&s->pb, 3, s->pict_type);
|
| 352 |
|
| 353 |
s->vbv_delay_ptr= s->pb.buf + put_bits_count(&s->pb)/8;
|
| 354 |
put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */ |
| 355 |
|
| 356 |
// RAL: Forward f_code also needed for B frames
|
| 357 |
if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) {
|
| 358 |
put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
| 359 |
if(s->codec_id == CODEC_ID_MPEG1VIDEO)
|
| 360 |
put_bits(&s->pb, 3, s->f_code); /* forward_f_code */ |
| 361 |
else
|
| 362 |
put_bits(&s->pb, 3, 7); /* forward_f_code */ |
| 363 |
} |
| 364 |
|
| 365 |
// RAL: Backward f_code necessary for B frames
|
| 366 |
if (s->pict_type == FF_B_TYPE) {
|
| 367 |
put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
| 368 |
if(s->codec_id == CODEC_ID_MPEG1VIDEO)
|
| 369 |
put_bits(&s->pb, 3, s->b_code); /* backward_f_code */ |
| 370 |
else
|
| 371 |
put_bits(&s->pb, 3, 7); /* backward_f_code */ |
| 372 |
} |
| 373 |
|
| 374 |
put_bits(&s->pb, 1, 0); /* extra bit picture */ |
| 375 |
|
| 376 |
s->frame_pred_frame_dct = 1;
|
| 377 |
if(s->codec_id == CODEC_ID_MPEG2VIDEO){
|
| 378 |
put_header(s, EXT_START_CODE); |
| 379 |
put_bits(&s->pb, 4, 8); //pic ext |
| 380 |
if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) {
|
| 381 |
put_bits(&s->pb, 4, s->f_code);
|
| 382 |
put_bits(&s->pb, 4, s->f_code);
|
| 383 |
}else{
|
| 384 |
put_bits(&s->pb, 8, 255); |
| 385 |
} |
| 386 |
if (s->pict_type == FF_B_TYPE) {
|
| 387 |
put_bits(&s->pb, 4, s->b_code);
|
| 388 |
put_bits(&s->pb, 4, s->b_code);
|
| 389 |
}else{
|
| 390 |
put_bits(&s->pb, 8, 255); |
| 391 |
} |
| 392 |
put_bits(&s->pb, 2, s->intra_dc_precision);
|
| 393 |
|
| 394 |
assert(s->picture_structure == PICT_FRAME); |
| 395 |
put_bits(&s->pb, 2, s->picture_structure);
|
| 396 |
if (s->progressive_sequence) {
|
| 397 |
put_bits(&s->pb, 1, 0); /* no repeat */ |
| 398 |
} else {
|
| 399 |
put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
|
| 400 |
} |
| 401 |
/* XXX: optimize the generation of this flag with entropy
|
| 402 |
measures */
|
| 403 |
s->frame_pred_frame_dct = s->progressive_sequence; |
| 404 |
|
| 405 |
put_bits(&s->pb, 1, s->frame_pred_frame_dct);
|
| 406 |
put_bits(&s->pb, 1, s->concealment_motion_vectors);
|
| 407 |
put_bits(&s->pb, 1, s->q_scale_type);
|
| 408 |
put_bits(&s->pb, 1, s->intra_vlc_format);
|
| 409 |
put_bits(&s->pb, 1, s->alternate_scan);
|
| 410 |
put_bits(&s->pb, 1, s->repeat_first_field);
|
| 411 |
s->progressive_frame = s->progressive_sequence; |
| 412 |
put_bits(&s->pb, 1, s->chroma_format == CHROMA_420 ? s->progressive_frame : 0); /* chroma_420_type */ |
| 413 |
put_bits(&s->pb, 1, s->progressive_frame);
|
| 414 |
put_bits(&s->pb, 1, 0); //composite_display_flag |
| 415 |
} |
| 416 |
if(s->flags & CODEC_FLAG_SVCD_SCAN_OFFSET){
|
| 417 |
int i;
|
| 418 |
|
| 419 |
put_header(s, USER_START_CODE); |
| 420 |
for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){ |
| 421 |
put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
|
| 422 |
} |
| 423 |
} |
| 424 |
|
| 425 |
s->mb_y=0;
|
| 426 |
ff_mpeg1_encode_slice_header(s); |
| 427 |
} |
| 428 |
|
| 429 |
static inline void put_mb_modes(MpegEncContext *s, int n, int bits, |
| 430 |
int has_mv, int field_motion) |
| 431 |
{
|
| 432 |
put_bits(&s->pb, n, bits); |
| 433 |
if (!s->frame_pred_frame_dct) {
|
| 434 |
if (has_mv)
|
| 435 |
put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */ |
| 436 |
put_bits(&s->pb, 1, s->interlaced_dct);
|
| 437 |
} |
| 438 |
} |
| 439 |
|
| 440 |
static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s, |
| 441 |
DCTELEM block[6][64], |
| 442 |
int motion_x, int motion_y, |
| 443 |
int mb_block_count)
|
| 444 |
{
|
| 445 |
int i, cbp;
|
| 446 |
const int mb_x = s->mb_x; |
| 447 |
const int mb_y = s->mb_y; |
| 448 |
const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y; |
| 449 |
|
| 450 |
/* compute cbp */
|
| 451 |
cbp = 0;
|
| 452 |
for(i=0;i<mb_block_count;i++) { |
| 453 |
if (s->block_last_index[i] >= 0) |
| 454 |
cbp |= 1 << (mb_block_count - 1 - i); |
| 455 |
} |
| 456 |
|
| 457 |
if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 && |
| 458 |
(mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) && |
| 459 |
((s->pict_type == FF_P_TYPE && (motion_x | motion_y) == 0) ||
|
| 460 |
(s->pict_type == FF_B_TYPE && s->mv_dir == s->last_mv_dir && (((s->mv_dir & MV_DIR_FORWARD) ? ((s->mv[0][0][0] - s->last_mv[0][0][0])|(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) | |
| 461 |
((s->mv_dir & MV_DIR_BACKWARD) ? ((s->mv[1][0][0] - s->last_mv[1][0][0])|(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) { |
| 462 |
s->mb_skip_run++; |
| 463 |
s->qscale -= s->dquant; |
| 464 |
s->skip_count++; |
| 465 |
s->misc_bits++; |
| 466 |
s->last_bits++; |
| 467 |
if(s->pict_type == FF_P_TYPE){
|
| 468 |
s->last_mv[0][1][0]= s->last_mv[0][0][0]= |
| 469 |
s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0; |
| 470 |
} |
| 471 |
} else {
|
| 472 |
if(first_mb){
|
| 473 |
assert(s->mb_skip_run == 0);
|
| 474 |
encode_mb_skip_run(s, s->mb_x); |
| 475 |
}else{
|
| 476 |
encode_mb_skip_run(s, s->mb_skip_run); |
| 477 |
} |
| 478 |
|
| 479 |
if (s->pict_type == FF_I_TYPE) {
|
| 480 |
if(s->dquant && cbp){
|
| 481 |
put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */ |
| 482 |
put_qscale(s); |
| 483 |
}else{
|
| 484 |
put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */ |
| 485 |
s->qscale -= s->dquant; |
| 486 |
} |
| 487 |
s->misc_bits+= get_bits_diff(s); |
| 488 |
s->i_count++; |
| 489 |
} else if (s->mb_intra) { |
| 490 |
if(s->dquant && cbp){
|
| 491 |
put_mb_modes(s, 6, 0x01, 0, 0); |
| 492 |
put_qscale(s); |
| 493 |
}else{
|
| 494 |
put_mb_modes(s, 5, 0x03, 0, 0); |
| 495 |
s->qscale -= s->dquant; |
| 496 |
} |
| 497 |
s->misc_bits+= get_bits_diff(s); |
| 498 |
s->i_count++; |
| 499 |
memset(s->last_mv, 0, sizeof(s->last_mv)); |
| 500 |
} else if (s->pict_type == FF_P_TYPE) { |
| 501 |
if(s->mv_type == MV_TYPE_16X16){
|
| 502 |
if (cbp != 0) { |
| 503 |
if ((motion_x|motion_y) == 0) { |
| 504 |
if(s->dquant){
|
| 505 |
put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */ |
| 506 |
put_qscale(s); |
| 507 |
}else{
|
| 508 |
put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */ |
| 509 |
} |
| 510 |
s->misc_bits+= get_bits_diff(s); |
| 511 |
} else {
|
| 512 |
if(s->dquant){
|
| 513 |
put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */ |
| 514 |
put_qscale(s); |
| 515 |
}else{
|
| 516 |
put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */ |
| 517 |
} |
| 518 |
s->misc_bits+= get_bits_diff(s); |
| 519 |
mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added |
| 520 |
mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added |
| 521 |
s->mv_bits+= get_bits_diff(s); |
| 522 |
} |
| 523 |
} else {
|
| 524 |
put_bits(&s->pb, 3, 1); /* motion only */ |
| 525 |
if (!s->frame_pred_frame_dct)
|
| 526 |
put_bits(&s->pb, 2, 2); /* motion_type: frame */ |
| 527 |
s->misc_bits+= get_bits_diff(s); |
| 528 |
mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added |
| 529 |
mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added |
| 530 |
s->qscale -= s->dquant; |
| 531 |
s->mv_bits+= get_bits_diff(s); |
| 532 |
} |
| 533 |
s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x; |
| 534 |
s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y; |
| 535 |
}else{
|
| 536 |
assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD); |
| 537 |
|
| 538 |
if (cbp) {
|
| 539 |
if(s->dquant){
|
| 540 |
put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */ |
| 541 |
put_qscale(s); |
| 542 |
}else{
|
| 543 |
put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */ |
| 544 |
} |
| 545 |
} else {
|
| 546 |
put_bits(&s->pb, 3, 1); /* motion only */ |
| 547 |
put_bits(&s->pb, 2, 1); /* motion_type: field */ |
| 548 |
s->qscale -= s->dquant; |
| 549 |
} |
| 550 |
s->misc_bits+= get_bits_diff(s); |
| 551 |
for(i=0; i<2; i++){ |
| 552 |
put_bits(&s->pb, 1, s->field_select[0][i]); |
| 553 |
mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); |
| 554 |
mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); |
| 555 |
s->last_mv[0][i][0]= s->mv[0][i][0]; |
| 556 |
s->last_mv[0][i][1]= 2*s->mv[0][i][1]; |
| 557 |
} |
| 558 |
s->mv_bits+= get_bits_diff(s); |
| 559 |
} |
| 560 |
if(cbp) {
|
| 561 |
if (s->chroma_y_shift) {
|
| 562 |
put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp][1], ff_mpeg12_mbPatTable[cbp][0]); |
| 563 |
} else {
|
| 564 |
put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp>>2][1], ff_mpeg12_mbPatTable[cbp>>2][0]); |
| 565 |
put_sbits(&s->pb, 2, cbp);
|
| 566 |
} |
| 567 |
} |
| 568 |
s->f_count++; |
| 569 |
} else{
|
| 570 |
if(s->mv_type == MV_TYPE_16X16){
|
| 571 |
if (cbp){ // With coded bloc pattern |
| 572 |
if (s->dquant) {
|
| 573 |
if(s->mv_dir == MV_DIR_FORWARD)
|
| 574 |
put_mb_modes(s, 6, 3, 1, 0); |
| 575 |
else
|
| 576 |
put_mb_modes(s, 8-s->mv_dir, 2, 1, 0); |
| 577 |
put_qscale(s); |
| 578 |
} else {
|
| 579 |
put_mb_modes(s, 5-s->mv_dir, 3, 1, 0); |
| 580 |
} |
| 581 |
}else{ // No coded bloc pattern |
| 582 |
put_bits(&s->pb, 5-s->mv_dir, 2); |
| 583 |
if (!s->frame_pred_frame_dct)
|
| 584 |
put_bits(&s->pb, 2, 2); /* motion_type: frame */ |
| 585 |
s->qscale -= s->dquant; |
| 586 |
} |
| 587 |
s->misc_bits += get_bits_diff(s); |
| 588 |
if (s->mv_dir&MV_DIR_FORWARD){
|
| 589 |
mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); |
| 590 |
mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); |
| 591 |
s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0]; |
| 592 |
s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1]; |
| 593 |
s->f_count++; |
| 594 |
} |
| 595 |
if (s->mv_dir&MV_DIR_BACKWARD){
|
| 596 |
mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); |
| 597 |
mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); |
| 598 |
s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0]; |
| 599 |
s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1]; |
| 600 |
s->b_count++; |
| 601 |
} |
| 602 |
}else{
|
| 603 |
assert(s->mv_type == MV_TYPE_FIELD); |
| 604 |
assert(!s->frame_pred_frame_dct); |
| 605 |
if (cbp){ // With coded bloc pattern |
| 606 |
if (s->dquant) {
|
| 607 |
if(s->mv_dir == MV_DIR_FORWARD)
|
| 608 |
put_mb_modes(s, 6, 3, 1, 1); |
| 609 |
else
|
| 610 |
put_mb_modes(s, 8-s->mv_dir, 2, 1, 1); |
| 611 |
put_qscale(s); |
| 612 |
} else {
|
| 613 |
put_mb_modes(s, 5-s->mv_dir, 3, 1, 1); |
| 614 |
} |
| 615 |
}else{ // No coded bloc pattern |
| 616 |
put_bits(&s->pb, 5-s->mv_dir, 2); |
| 617 |
put_bits(&s->pb, 2, 1); /* motion_type: field */ |
| 618 |
s->qscale -= s->dquant; |
| 619 |
} |
| 620 |
s->misc_bits += get_bits_diff(s); |
| 621 |
if (s->mv_dir&MV_DIR_FORWARD){
|
| 622 |
for(i=0; i<2; i++){ |
| 623 |
put_bits(&s->pb, 1, s->field_select[0][i]); |
| 624 |
mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); |
| 625 |
mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); |
| 626 |
s->last_mv[0][i][0]= s->mv[0][i][0]; |
| 627 |
s->last_mv[0][i][1]= 2*s->mv[0][i][1]; |
| 628 |
} |
| 629 |
s->f_count++; |
| 630 |
} |
| 631 |
if (s->mv_dir&MV_DIR_BACKWARD){
|
| 632 |
for(i=0; i<2; i++){ |
| 633 |
put_bits(&s->pb, 1, s->field_select[1][i]); |
| 634 |
mpeg1_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code); |
| 635 |
mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code); |
| 636 |
s->last_mv[1][i][0]= s->mv[1][i][0]; |
| 637 |
s->last_mv[1][i][1]= 2*s->mv[1][i][1]; |
| 638 |
} |
| 639 |
s->b_count++; |
| 640 |
} |
| 641 |
} |
| 642 |
s->mv_bits += get_bits_diff(s); |
| 643 |
if(cbp) {
|
| 644 |
if (s->chroma_y_shift) {
|
| 645 |
put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp][1], ff_mpeg12_mbPatTable[cbp][0]); |
| 646 |
} else {
|
| 647 |
put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp>>2][1], ff_mpeg12_mbPatTable[cbp>>2][0]); |
| 648 |
put_sbits(&s->pb, 2, cbp);
|
| 649 |
} |
| 650 |
} |
| 651 |
} |
| 652 |
for(i=0;i<mb_block_count;i++) { |
| 653 |
if (cbp & (1 << (mb_block_count - 1 - i))) { |
| 654 |
mpeg1_encode_block(s, block[i], i); |
| 655 |
} |
| 656 |
} |
| 657 |
s->mb_skip_run = 0;
|
| 658 |
if(s->mb_intra)
|
| 659 |
s->i_tex_bits+= get_bits_diff(s); |
| 660 |
else
|
| 661 |
s->p_tex_bits+= get_bits_diff(s); |
| 662 |
} |
| 663 |
} |
| 664 |
|
| 665 |
void mpeg1_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y) |
| 666 |
{
|
| 667 |
if (s->chroma_format == CHROMA_420) mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6); |
| 668 |
else mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8); |
| 669 |
} |
| 670 |
|
| 671 |
// RAL: Parameter added: f_or_b_code
|
| 672 |
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code) |
| 673 |
{
|
| 674 |
if (val == 0) { |
| 675 |
/* zero vector */
|
| 676 |
put_bits(&s->pb, |
| 677 |
ff_mpeg12_mbMotionVectorTable[0][1], |
| 678 |
ff_mpeg12_mbMotionVectorTable[0][0]); |
| 679 |
} else {
|
| 680 |
int code, sign, bits;
|
| 681 |
int bit_size = f_or_b_code - 1; |
| 682 |
int range = 1 << bit_size; |
| 683 |
/* modulo encoding */
|
| 684 |
int l= INT_BIT - 5 - bit_size; |
| 685 |
val= (val<<l)>>l; |
| 686 |
|
| 687 |
if (val >= 0) { |
| 688 |
val--; |
| 689 |
code = (val >> bit_size) + 1;
|
| 690 |
bits = val & (range - 1);
|
| 691 |
sign = 0;
|
| 692 |
} else {
|
| 693 |
val = -val; |
| 694 |
val--; |
| 695 |
code = (val >> bit_size) + 1;
|
| 696 |
bits = val & (range - 1);
|
| 697 |
sign = 1;
|
| 698 |
} |
| 699 |
|
| 700 |
assert(code > 0 && code <= 16); |
| 701 |
|
| 702 |
put_bits(&s->pb, |
| 703 |
ff_mpeg12_mbMotionVectorTable[code][1],
|
| 704 |
ff_mpeg12_mbMotionVectorTable[code][0]);
|
| 705 |
|
| 706 |
put_bits(&s->pb, 1, sign);
|
| 707 |
if (bit_size > 0) { |
| 708 |
put_bits(&s->pb, bit_size, bits); |
| 709 |
} |
| 710 |
} |
| 711 |
} |
| 712 |
|
| 713 |
void ff_mpeg1_encode_init(MpegEncContext *s)
|
| 714 |
{
|
| 715 |
static int done=0; |
| 716 |
|
| 717 |
ff_mpeg12_common_init(s); |
| 718 |
|
| 719 |
if(!done){
|
| 720 |
int f_code;
|
| 721 |
int mv;
|
| 722 |
int i;
|
| 723 |
|
| 724 |
done=1;
|
| 725 |
init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]);
|
| 726 |
init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]);
|
| 727 |
|
| 728 |
for(i=0; i<64; i++) |
| 729 |
{
|
| 730 |
mpeg1_max_level[0][i]= ff_rl_mpeg1.max_level[0][i]; |
| 731 |
mpeg1_index_run[0][i]= ff_rl_mpeg1.index_run[0][i]; |
| 732 |
} |
| 733 |
|
| 734 |
init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len); |
| 735 |
if(s->intra_vlc_format)
|
| 736 |
init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len); |
| 737 |
|
| 738 |
/* build unified dc encoding tables */
|
| 739 |
for(i=-255; i<256; i++) |
| 740 |
{
|
| 741 |
int adiff, index;
|
| 742 |
int bits, code;
|
| 743 |
int diff=i;
|
| 744 |
|
| 745 |
adiff = FFABS(diff); |
| 746 |
if(diff<0) diff--; |
| 747 |
index = av_log2(2*adiff);
|
| 748 |
|
| 749 |
bits= ff_mpeg12_vlc_dc_lum_bits[index] + index; |
| 750 |
code= (ff_mpeg12_vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1)); |
| 751 |
mpeg1_lum_dc_uni[i+255]= bits + (code<<8); |
| 752 |
|
| 753 |
bits= ff_mpeg12_vlc_dc_chroma_bits[index] + index; |
| 754 |
code= (ff_mpeg12_vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1)); |
| 755 |
mpeg1_chr_dc_uni[i+255]= bits + (code<<8); |
| 756 |
} |
| 757 |
|
| 758 |
for(f_code=1; f_code<=MAX_FCODE; f_code++){ |
| 759 |
for(mv=-MAX_MV; mv<=MAX_MV; mv++){
|
| 760 |
int len;
|
| 761 |
|
| 762 |
if(mv==0) len= ff_mpeg12_mbMotionVectorTable[0][1]; |
| 763 |
else{
|
| 764 |
int val, bit_size, range, code;
|
| 765 |
|
| 766 |
bit_size = f_code - 1;
|
| 767 |
range = 1 << bit_size;
|
| 768 |
|
| 769 |
val=mv; |
| 770 |
if (val < 0) |
| 771 |
val = -val; |
| 772 |
val--; |
| 773 |
code = (val >> bit_size) + 1;
|
| 774 |
if(code<17){ |
| 775 |
len= ff_mpeg12_mbMotionVectorTable[code][1] + 1 + bit_size; |
| 776 |
}else{
|
| 777 |
len= ff_mpeg12_mbMotionVectorTable[16][1] + 2 + bit_size; |
| 778 |
} |
| 779 |
} |
| 780 |
|
| 781 |
mv_penalty[f_code][mv+MAX_MV]= len; |
| 782 |
} |
| 783 |
} |
| 784 |
|
| 785 |
|
| 786 |
for(f_code=MAX_FCODE; f_code>0; f_code--){ |
| 787 |
for(mv=-(8<<f_code); mv<(8<<f_code); mv++){ |
| 788 |
fcode_tab[mv+MAX_MV]= f_code; |
| 789 |
} |
| 790 |
} |
| 791 |
} |
| 792 |
s->me.mv_penalty= mv_penalty; |
| 793 |
s->fcode_tab= fcode_tab; |
| 794 |
if(s->codec_id == CODEC_ID_MPEG1VIDEO){
|
| 795 |
s->min_qcoeff=-255;
|
| 796 |
s->max_qcoeff= 255;
|
| 797 |
}else{
|
| 798 |
s->min_qcoeff=-2047;
|
| 799 |
s->max_qcoeff= 2047;
|
| 800 |
} |
| 801 |
if (s->intra_vlc_format) {
|
| 802 |
s->intra_ac_vlc_length= |
| 803 |
s->intra_ac_vlc_last_length= uni_mpeg2_ac_vlc_len; |
| 804 |
} else {
|
| 805 |
s->intra_ac_vlc_length= |
| 806 |
s->intra_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; |
| 807 |
} |
| 808 |
s->inter_ac_vlc_length= |
| 809 |
s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; |
| 810 |
} |
| 811 |
|
| 812 |
static inline void encode_dc(MpegEncContext *s, int diff, int component) |
| 813 |
{
|
| 814 |
if(((unsigned) (diff+255)) >= 511){ |
| 815 |
int index;
|
| 816 |
|
| 817 |
if(diff<0){ |
| 818 |
index= av_log2_16bit(-2*diff);
|
| 819 |
diff--; |
| 820 |
}else{
|
| 821 |
index= av_log2_16bit(2*diff);
|
| 822 |
} |
| 823 |
if (component == 0) { |
| 824 |
put_bits( |
| 825 |
&s->pb, |
| 826 |
ff_mpeg12_vlc_dc_lum_bits[index] + index, |
| 827 |
(ff_mpeg12_vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1))); |
| 828 |
}else{
|
| 829 |
put_bits( |
| 830 |
&s->pb, |
| 831 |
ff_mpeg12_vlc_dc_chroma_bits[index] + index, |
| 832 |
(ff_mpeg12_vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1))); |
| 833 |
} |
| 834 |
}else{
|
| 835 |
if (component == 0) { |
| 836 |
put_bits( |
| 837 |
&s->pb, |
| 838 |
mpeg1_lum_dc_uni[diff+255]&0xFF, |
| 839 |
mpeg1_lum_dc_uni[diff+255]>>8); |
| 840 |
} else {
|
| 841 |
put_bits( |
| 842 |
&s->pb, |
| 843 |
mpeg1_chr_dc_uni[diff+255]&0xFF, |
| 844 |
mpeg1_chr_dc_uni[diff+255]>>8); |
| 845 |
} |
| 846 |
} |
| 847 |
} |
| 848 |
|
| 849 |
static void mpeg1_encode_block(MpegEncContext *s, |
| 850 |
DCTELEM *block, |
| 851 |
int n)
|
| 852 |
{
|
| 853 |
int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
|
| 854 |
int code, component;
|
| 855 |
const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc; |
| 856 |
|
| 857 |
last_index = s->block_last_index[n]; |
| 858 |
|
| 859 |
/* DC coef */
|
| 860 |
if (s->mb_intra) {
|
| 861 |
component = (n <= 3 ? 0 : (n&1) + 1); |
| 862 |
dc = block[0]; /* overflow is impossible */ |
| 863 |
diff = dc - s->last_dc[component]; |
| 864 |
encode_dc(s, diff, component); |
| 865 |
s->last_dc[component] = dc; |
| 866 |
i = 1;
|
| 867 |
if (s->intra_vlc_format)
|
| 868 |
table_vlc = ff_rl_mpeg2.table_vlc; |
| 869 |
} else {
|
| 870 |
/* encode the first coefficient : needs to be done here because
|
| 871 |
it is handled slightly differently */
|
| 872 |
level = block[0];
|
| 873 |
if (abs(level) == 1) { |
| 874 |
code = ((uint32_t)level >> 31); /* the sign bit */ |
| 875 |
put_bits(&s->pb, 2, code | 0x02); |
| 876 |
i = 1;
|
| 877 |
} else {
|
| 878 |
i = 0;
|
| 879 |
last_non_zero = -1;
|
| 880 |
goto next_coef;
|
| 881 |
} |
| 882 |
} |
| 883 |
|
| 884 |
/* now quantify & encode AC coefs */
|
| 885 |
last_non_zero = i - 1;
|
| 886 |
|
| 887 |
for(;i<=last_index;i++) {
|
| 888 |
j = s->intra_scantable.permutated[i]; |
| 889 |
level = block[j]; |
| 890 |
next_coef:
|
| 891 |
#if 0
|
| 892 |
if (level != 0)
|
| 893 |
dprintf(s->avctx, "level[%d]=%d\n", i, level);
|
| 894 |
#endif
|
| 895 |
/* encode using VLC */
|
| 896 |
if (level != 0) { |
| 897 |
run = i - last_non_zero - 1;
|
| 898 |
|
| 899 |
alevel= level; |
| 900 |
MASK_ABS(sign, alevel) |
| 901 |
sign&=1;
|
| 902 |
|
| 903 |
if (alevel <= mpeg1_max_level[0][run]){ |
| 904 |
code= mpeg1_index_run[0][run] + alevel - 1; |
| 905 |
/* store the vlc & sign at once */
|
| 906 |
put_bits(&s->pb, table_vlc[code][1]+1, (table_vlc[code][0]<<1) + sign); |
| 907 |
} else {
|
| 908 |
/* escape seems to be pretty rare <5% so I do not optimize it */
|
| 909 |
put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]); |
| 910 |
/* escape: only clip in this case */
|
| 911 |
put_bits(&s->pb, 6, run);
|
| 912 |
if(s->codec_id == CODEC_ID_MPEG1VIDEO){
|
| 913 |
if (alevel < 128) { |
| 914 |
put_sbits(&s->pb, 8, level);
|
| 915 |
} else {
|
| 916 |
if (level < 0) { |
| 917 |
put_bits(&s->pb, 16, 0x8001 + level + 255); |
| 918 |
} else {
|
| 919 |
put_sbits(&s->pb, 16, level);
|
| 920 |
} |
| 921 |
} |
| 922 |
}else{
|
| 923 |
put_sbits(&s->pb, 12, level);
|
| 924 |
} |
| 925 |
} |
| 926 |
last_non_zero = i; |
| 927 |
} |
| 928 |
} |
| 929 |
/* end of block */
|
| 930 |
put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]); |
| 931 |
} |
| 932 |
|
| 933 |
AVCodec ff_mpeg1video_encoder = {
|
| 934 |
"mpeg1video",
|
| 935 |
AVMEDIA_TYPE_VIDEO, |
| 936 |
CODEC_ID_MPEG1VIDEO, |
| 937 |
sizeof(MpegEncContext),
|
| 938 |
encode_init, |
| 939 |
MPV_encode_picture, |
| 940 |
MPV_encode_end, |
| 941 |
.supported_framerates= ff_frame_rate_tab+1,
|
| 942 |
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
| 943 |
.capabilities= CODEC_CAP_DELAY, |
| 944 |
.long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
|
| 945 |
}; |
| 946 |
|
| 947 |
AVCodec ff_mpeg2video_encoder = {
|
| 948 |
"mpeg2video",
|
| 949 |
AVMEDIA_TYPE_VIDEO, |
| 950 |
CODEC_ID_MPEG2VIDEO, |
| 951 |
sizeof(MpegEncContext),
|
| 952 |
encode_init, |
| 953 |
MPV_encode_picture, |
| 954 |
MPV_encode_end, |
| 955 |
.supported_framerates= ff_frame_rate_tab+1,
|
| 956 |
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE}, |
| 957 |
.capabilities= CODEC_CAP_DELAY, |
| 958 |
.long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"),
|
| 959 |
}; |