Mercurial > libavcodec.hg
annotate mpeg12enc.c @ 7354:456957d86106 libavcodec
My commit at r14340 was not the right solution. For a monochromatic
frame, there will be only one centroid and it will be impossible to
find three distinct ones. It is better to just avoid shifting if
there are not three different centroids.
author | vitor |
---|---|
date | Wed, 23 Jul 2008 05:54:34 +0000 |
parents | 3ec34b551aae |
children | 04423b2f6e0b |
rev | line source |
---|---|
5208 | 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 mpeg12enc.c | |
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_INOFFICIAL && 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 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
136 static av_cold int encode_init(AVCodecContext *avctx) |
5208 | 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); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
187 put_sbits(&s->pb, 16, header); |
5208 | 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 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
209 put_sbits(&s->pb, 12, s->width ); |
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
210 put_sbits(&s->pb, 12, s->height); |
5208 | 211 |
212 for(i=1; i<15; i++){ | |
213 float error= aspect_ratio; | |
214 if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1) | |
5210 | 215 error-= 1.0/ff_mpeg1_aspect[i]; |
5208 | 216 else |
5210 | 217 error-= av_q2d(ff_mpeg2_aspect[i])*s->height/s->width; |
5208 | 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 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
245 put_sbits(&s->pb, 18, v); |
5208 | 246 put_bits(&s->pb, 1, 1); /* marker */ |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
247 put_sbits(&s->pb, 10, vbv_buffer_size); |
5208 | 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); | |
7143 | 275 put_bits(&s->pb, 2, s->width >>12); |
276 put_bits(&s->pb, 2, s->height>>12); | |
5208 | 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 } | |
5210 | 315 put_bits(&s->pb, ff_mpeg12_mbAddrIncrTable[run][1], |
316 ff_mpeg12_mbAddrIncrTable[run][0]); | |
5208 | 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 put_header(s, SLICE_MIN_START_CODE + s->mb_y); | |
331 put_qscale(s); | |
332 put_bits(&s->pb, 1, 0); /* slice extra information */ | |
333 } | |
334 | |
335 void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) | |
336 { | |
337 mpeg1_encode_sequence_header(s); | |
338 | |
339 /* mpeg1 picture header */ | |
340 put_header(s, PICTURE_START_CODE); | |
341 /* temporal reference */ | |
342 | |
343 // RAL: s->picture_number instead of s->fake_picture_number | |
344 put_bits(&s->pb, 10, (s->picture_number - | |
345 s->gop_picture_number) & 0x3ff); | |
346 put_bits(&s->pb, 3, s->pict_type); | |
347 | |
348 s->vbv_delay_ptr= s->pb.buf + put_bits_count(&s->pb)/8; | |
349 put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */ | |
350 | |
351 // RAL: Forward f_code also needed for B frames | |
6481 | 352 if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) { |
5208 | 353 put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
354 if(s->codec_id == CODEC_ID_MPEG1VIDEO) | |
355 put_bits(&s->pb, 3, s->f_code); /* forward_f_code */ | |
356 else | |
357 put_bits(&s->pb, 3, 7); /* forward_f_code */ | |
358 } | |
359 | |
360 // RAL: Backward f_code necessary for B frames | |
6481 | 361 if (s->pict_type == FF_B_TYPE) { |
5208 | 362 put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
363 if(s->codec_id == CODEC_ID_MPEG1VIDEO) | |
364 put_bits(&s->pb, 3, s->b_code); /* backward_f_code */ | |
365 else | |
366 put_bits(&s->pb, 3, 7); /* backward_f_code */ | |
367 } | |
368 | |
369 put_bits(&s->pb, 1, 0); /* extra bit picture */ | |
370 | |
371 s->frame_pred_frame_dct = 1; | |
372 if(s->codec_id == CODEC_ID_MPEG2VIDEO){ | |
373 put_header(s, EXT_START_CODE); | |
374 put_bits(&s->pb, 4, 8); //pic ext | |
6481 | 375 if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) { |
5208 | 376 put_bits(&s->pb, 4, s->f_code); |
377 put_bits(&s->pb, 4, s->f_code); | |
378 }else{ | |
379 put_bits(&s->pb, 8, 255); | |
380 } | |
6481 | 381 if (s->pict_type == FF_B_TYPE) { |
5208 | 382 put_bits(&s->pb, 4, s->b_code); |
383 put_bits(&s->pb, 4, s->b_code); | |
384 }else{ | |
385 put_bits(&s->pb, 8, 255); | |
386 } | |
387 put_bits(&s->pb, 2, s->intra_dc_precision); | |
388 | |
389 assert(s->picture_structure == PICT_FRAME); | |
390 put_bits(&s->pb, 2, s->picture_structure); | |
391 if (s->progressive_sequence) { | |
392 put_bits(&s->pb, 1, 0); /* no repeat */ | |
393 } else { | |
394 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); | |
395 } | |
396 /* XXX: optimize the generation of this flag with entropy | |
397 measures */ | |
398 s->frame_pred_frame_dct = s->progressive_sequence; | |
399 | |
400 put_bits(&s->pb, 1, s->frame_pred_frame_dct); | |
401 put_bits(&s->pb, 1, s->concealment_motion_vectors); | |
402 put_bits(&s->pb, 1, s->q_scale_type); | |
403 put_bits(&s->pb, 1, s->intra_vlc_format); | |
404 put_bits(&s->pb, 1, s->alternate_scan); | |
405 put_bits(&s->pb, 1, s->repeat_first_field); | |
406 s->progressive_frame = s->progressive_sequence; | |
407 put_bits(&s->pb, 1, s->chroma_format == CHROMA_420 ? s->progressive_frame : 0); /* chroma_420_type */ | |
408 put_bits(&s->pb, 1, s->progressive_frame); | |
409 put_bits(&s->pb, 1, 0); //composite_display_flag | |
410 } | |
411 if(s->flags & CODEC_FLAG_SVCD_SCAN_OFFSET){ | |
412 int i; | |
413 | |
414 put_header(s, USER_START_CODE); | |
415 for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){ | |
416 put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]); | |
417 } | |
418 } | |
419 | |
420 s->mb_y=0; | |
421 ff_mpeg1_encode_slice_header(s); | |
422 } | |
423 | |
424 static inline void put_mb_modes(MpegEncContext *s, int n, int bits, | |
425 int has_mv, int field_motion) | |
426 { | |
427 put_bits(&s->pb, n, bits); | |
428 if (!s->frame_pred_frame_dct) { | |
429 if (has_mv) | |
430 put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */ | |
431 put_bits(&s->pb, 1, s->interlaced_dct); | |
432 } | |
433 } | |
434 | |
435 static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s, | |
436 DCTELEM block[6][64], | |
437 int motion_x, int motion_y, | |
438 int mb_block_count) | |
439 { | |
440 int i, cbp; | |
441 const int mb_x = s->mb_x; | |
442 const int mb_y = s->mb_y; | |
443 const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y; | |
444 | |
445 /* compute cbp */ | |
446 cbp = 0; | |
447 for(i=0;i<mb_block_count;i++) { | |
448 if (s->block_last_index[i] >= 0) | |
449 cbp |= 1 << (mb_block_count - 1 - i); | |
450 } | |
451 | |
452 if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 && | |
453 (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) && | |
6481 | 454 ((s->pict_type == FF_P_TYPE && (motion_x | motion_y) == 0) || |
455 (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) | | |
5208 | 456 ((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))) { |
457 s->mb_skip_run++; | |
458 s->qscale -= s->dquant; | |
459 s->skip_count++; | |
460 s->misc_bits++; | |
461 s->last_bits++; | |
6481 | 462 if(s->pict_type == FF_P_TYPE){ |
5208 | 463 s->last_mv[0][1][0]= s->last_mv[0][0][0]= |
464 s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0; | |
465 } | |
466 } else { | |
467 if(first_mb){ | |
468 assert(s->mb_skip_run == 0); | |
469 encode_mb_skip_run(s, s->mb_x); | |
470 }else{ | |
471 encode_mb_skip_run(s, s->mb_skip_run); | |
472 } | |
473 | |
6481 | 474 if (s->pict_type == FF_I_TYPE) { |
5208 | 475 if(s->dquant && cbp){ |
476 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */ | |
477 put_qscale(s); | |
478 }else{ | |
479 put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */ | |
480 s->qscale -= s->dquant; | |
481 } | |
482 s->misc_bits+= get_bits_diff(s); | |
483 s->i_count++; | |
484 } else if (s->mb_intra) { | |
485 if(s->dquant && cbp){ | |
486 put_mb_modes(s, 6, 0x01, 0, 0); | |
487 put_qscale(s); | |
488 }else{ | |
489 put_mb_modes(s, 5, 0x03, 0, 0); | |
490 s->qscale -= s->dquant; | |
491 } | |
492 s->misc_bits+= get_bits_diff(s); | |
493 s->i_count++; | |
494 memset(s->last_mv, 0, sizeof(s->last_mv)); | |
6481 | 495 } else if (s->pict_type == FF_P_TYPE) { |
5208 | 496 if(s->mv_type == MV_TYPE_16X16){ |
497 if (cbp != 0) { | |
498 if ((motion_x|motion_y) == 0) { | |
499 if(s->dquant){ | |
500 put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */ | |
501 put_qscale(s); | |
502 }else{ | |
503 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */ | |
504 } | |
505 s->misc_bits+= get_bits_diff(s); | |
506 } else { | |
507 if(s->dquant){ | |
508 put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */ | |
509 put_qscale(s); | |
510 }else{ | |
511 put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */ | |
512 } | |
513 s->misc_bits+= get_bits_diff(s); | |
514 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added | |
515 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added | |
516 s->mv_bits+= get_bits_diff(s); | |
517 } | |
518 } else { | |
519 put_bits(&s->pb, 3, 1); /* motion only */ | |
520 if (!s->frame_pred_frame_dct) | |
521 put_bits(&s->pb, 2, 2); /* motion_type: frame */ | |
522 s->misc_bits+= get_bits_diff(s); | |
523 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added | |
524 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added | |
525 s->qscale -= s->dquant; | |
526 s->mv_bits+= get_bits_diff(s); | |
527 } | |
528 s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x; | |
529 s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y; | |
530 }else{ | |
531 assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD); | |
532 | |
533 if (cbp) { | |
534 if(s->dquant){ | |
535 put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */ | |
536 put_qscale(s); | |
537 }else{ | |
538 put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */ | |
539 } | |
540 } else { | |
541 put_bits(&s->pb, 3, 1); /* motion only */ | |
542 put_bits(&s->pb, 2, 1); /* motion_type: field */ | |
543 s->qscale -= s->dquant; | |
544 } | |
545 s->misc_bits+= get_bits_diff(s); | |
546 for(i=0; i<2; i++){ | |
547 put_bits(&s->pb, 1, s->field_select[0][i]); | |
548 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); | |
549 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); | |
550 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
551 s->last_mv[0][i][1]= 2*s->mv[0][i][1]; | |
552 } | |
553 s->mv_bits+= get_bits_diff(s); | |
554 } | |
555 if(cbp) { | |
556 if (s->chroma_y_shift) { | |
5210 | 557 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp][1], ff_mpeg12_mbPatTable[cbp][0]); |
5208 | 558 } else { |
5210 | 559 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp>>2][1], ff_mpeg12_mbPatTable[cbp>>2][0]); |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
560 put_sbits(&s->pb, 2, cbp); |
5208 | 561 } |
562 } | |
563 s->f_count++; | |
564 } else{ | |
565 if(s->mv_type == MV_TYPE_16X16){ | |
566 if (cbp){ // With coded bloc pattern | |
567 if (s->dquant) { | |
568 if(s->mv_dir == MV_DIR_FORWARD) | |
569 put_mb_modes(s, 6, 3, 1, 0); | |
570 else | |
5446 | 571 put_mb_modes(s, 8-s->mv_dir, 2, 1, 0); |
5208 | 572 put_qscale(s); |
573 } else { | |
5446 | 574 put_mb_modes(s, 5-s->mv_dir, 3, 1, 0); |
5208 | 575 } |
576 }else{ // No coded bloc pattern | |
5446 | 577 put_bits(&s->pb, 5-s->mv_dir, 2); |
5208 | 578 if (!s->frame_pred_frame_dct) |
579 put_bits(&s->pb, 2, 2); /* motion_type: frame */ | |
580 s->qscale -= s->dquant; | |
581 } | |
582 s->misc_bits += get_bits_diff(s); | |
583 if (s->mv_dir&MV_DIR_FORWARD){ | |
584 mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); | |
585 mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
586 s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0]; | |
587 s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1]; | |
588 s->f_count++; | |
589 } | |
590 if (s->mv_dir&MV_DIR_BACKWARD){ | |
591 mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); | |
592 mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
593 s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0]; | |
594 s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1]; | |
595 s->b_count++; | |
596 } | |
597 }else{ | |
598 assert(s->mv_type == MV_TYPE_FIELD); | |
599 assert(!s->frame_pred_frame_dct); | |
600 if (cbp){ // With coded bloc pattern | |
601 if (s->dquant) { | |
602 if(s->mv_dir == MV_DIR_FORWARD) | |
603 put_mb_modes(s, 6, 3, 1, 1); | |
604 else | |
5446 | 605 put_mb_modes(s, 8-s->mv_dir, 2, 1, 1); |
5208 | 606 put_qscale(s); |
607 } else { | |
5446 | 608 put_mb_modes(s, 5-s->mv_dir, 3, 1, 1); |
5208 | 609 } |
610 }else{ // No coded bloc pattern | |
5446 | 611 put_bits(&s->pb, 5-s->mv_dir, 2); |
5208 | 612 put_bits(&s->pb, 2, 1); /* motion_type: field */ |
613 s->qscale -= s->dquant; | |
614 } | |
615 s->misc_bits += get_bits_diff(s); | |
616 if (s->mv_dir&MV_DIR_FORWARD){ | |
617 for(i=0; i<2; i++){ | |
618 put_bits(&s->pb, 1, s->field_select[0][i]); | |
619 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); | |
620 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); | |
621 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
622 s->last_mv[0][i][1]= 2*s->mv[0][i][1]; | |
623 } | |
624 s->f_count++; | |
625 } | |
626 if (s->mv_dir&MV_DIR_BACKWARD){ | |
627 for(i=0; i<2; i++){ | |
628 put_bits(&s->pb, 1, s->field_select[1][i]); | |
629 mpeg1_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code); | |
630 mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code); | |
631 s->last_mv[1][i][0]= s->mv[1][i][0]; | |
632 s->last_mv[1][i][1]= 2*s->mv[1][i][1]; | |
633 } | |
634 s->b_count++; | |
635 } | |
636 } | |
637 s->mv_bits += get_bits_diff(s); | |
638 if(cbp) { | |
639 if (s->chroma_y_shift) { | |
5210 | 640 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp][1], ff_mpeg12_mbPatTable[cbp][0]); |
5208 | 641 } else { |
5210 | 642 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp>>2][1], ff_mpeg12_mbPatTable[cbp>>2][0]); |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
643 put_sbits(&s->pb, 2, cbp); |
5208 | 644 } |
645 } | |
646 } | |
647 for(i=0;i<mb_block_count;i++) { | |
648 if (cbp & (1 << (mb_block_count - 1 - i))) { | |
649 mpeg1_encode_block(s, block[i], i); | |
650 } | |
651 } | |
652 s->mb_skip_run = 0; | |
653 if(s->mb_intra) | |
654 s->i_tex_bits+= get_bits_diff(s); | |
655 else | |
656 s->p_tex_bits+= get_bits_diff(s); | |
657 } | |
658 } | |
659 | |
660 void mpeg1_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y) | |
661 { | |
662 if (s->chroma_format == CHROMA_420) mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6); | |
663 else mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8); | |
664 } | |
665 | |
666 // RAL: Parameter added: f_or_b_code | |
667 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code) | |
668 { | |
669 int code, bit_size, l, bits, range, sign; | |
670 | |
671 if (val == 0) { | |
672 /* zero vector */ | |
673 code = 0; | |
674 put_bits(&s->pb, | |
5210 | 675 ff_mpeg12_mbMotionVectorTable[0][1], |
676 ff_mpeg12_mbMotionVectorTable[0][0]); | |
5208 | 677 } else { |
678 bit_size = f_or_b_code - 1; | |
679 range = 1 << bit_size; | |
680 /* modulo encoding */ | |
681 l= INT_BIT - 5 - bit_size; | |
682 val= (val<<l)>>l; | |
683 | |
684 if (val >= 0) { | |
685 val--; | |
686 code = (val >> bit_size) + 1; | |
687 bits = val & (range - 1); | |
688 sign = 0; | |
689 } else { | |
690 val = -val; | |
691 val--; | |
692 code = (val >> bit_size) + 1; | |
693 bits = val & (range - 1); | |
694 sign = 1; | |
695 } | |
696 | |
697 assert(code > 0 && code <= 16); | |
698 | |
699 put_bits(&s->pb, | |
5210 | 700 ff_mpeg12_mbMotionVectorTable[code][1], |
701 ff_mpeg12_mbMotionVectorTable[code][0]); | |
5208 | 702 |
703 put_bits(&s->pb, 1, sign); | |
704 if (bit_size > 0) { | |
705 put_bits(&s->pb, bit_size, bits); | |
706 } | |
707 } | |
708 } | |
709 | |
710 void ff_mpeg1_encode_init(MpegEncContext *s) | |
711 { | |
712 static int done=0; | |
713 | |
5210 | 714 ff_mpeg12_common_init(s); |
5208 | 715 |
716 if(!done){ | |
717 int f_code; | |
718 int mv; | |
719 int i; | |
720 | |
721 done=1; | |
5210 | 722 init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]); |
723 init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]); | |
5208 | 724 |
725 for(i=0; i<64; i++) | |
726 { | |
5210 | 727 mpeg1_max_level[0][i]= ff_rl_mpeg1.max_level[0][i]; |
728 mpeg1_index_run[0][i]= ff_rl_mpeg1.index_run[0][i]; | |
5208 | 729 } |
730 | |
5210 | 731 init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len); |
5208 | 732 if(s->intra_vlc_format) |
5210 | 733 init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len); |
5208 | 734 |
735 /* build unified dc encoding tables */ | |
736 for(i=-255; i<256; i++) | |
737 { | |
738 int adiff, index; | |
739 int bits, code; | |
740 int diff=i; | |
741 | |
742 adiff = FFABS(diff); | |
743 if(diff<0) diff--; | |
744 index = av_log2(2*adiff); | |
745 | |
5210 | 746 bits= ff_mpeg12_vlc_dc_lum_bits[index] + index; |
747 code= (ff_mpeg12_vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1)); | |
5208 | 748 mpeg1_lum_dc_uni[i+255]= bits + (code<<8); |
749 | |
5210 | 750 bits= ff_mpeg12_vlc_dc_chroma_bits[index] + index; |
751 code= (ff_mpeg12_vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1)); | |
5208 | 752 mpeg1_chr_dc_uni[i+255]= bits + (code<<8); |
753 } | |
754 | |
755 for(f_code=1; f_code<=MAX_FCODE; f_code++){ | |
756 for(mv=-MAX_MV; mv<=MAX_MV; mv++){ | |
757 int len; | |
758 | |
5210 | 759 if(mv==0) len= ff_mpeg12_mbMotionVectorTable[0][1]; |
5208 | 760 else{ |
761 int val, bit_size, range, code; | |
762 | |
763 bit_size = f_code - 1; | |
764 range = 1 << bit_size; | |
765 | |
766 val=mv; | |
767 if (val < 0) | |
768 val = -val; | |
769 val--; | |
770 code = (val >> bit_size) + 1; | |
771 if(code<17){ | |
5210 | 772 len= ff_mpeg12_mbMotionVectorTable[code][1] + 1 + bit_size; |
5208 | 773 }else{ |
5210 | 774 len= ff_mpeg12_mbMotionVectorTable[16][1] + 2 + bit_size; |
5208 | 775 } |
776 } | |
777 | |
778 mv_penalty[f_code][mv+MAX_MV]= len; | |
779 } | |
780 } | |
781 | |
782 | |
783 for(f_code=MAX_FCODE; f_code>0; f_code--){ | |
784 for(mv=-(8<<f_code); mv<(8<<f_code); mv++){ | |
785 fcode_tab[mv+MAX_MV]= f_code; | |
786 } | |
787 } | |
788 } | |
789 s->me.mv_penalty= mv_penalty; | |
790 s->fcode_tab= fcode_tab; | |
791 if(s->codec_id == CODEC_ID_MPEG1VIDEO){ | |
792 s->min_qcoeff=-255; | |
793 s->max_qcoeff= 255; | |
794 }else{ | |
795 s->min_qcoeff=-2047; | |
796 s->max_qcoeff= 2047; | |
797 } | |
798 if (s->intra_vlc_format) { | |
799 s->intra_ac_vlc_length= | |
800 s->intra_ac_vlc_last_length= uni_mpeg2_ac_vlc_len; | |
801 } else { | |
802 s->intra_ac_vlc_length= | |
803 s->intra_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; | |
804 } | |
805 s->inter_ac_vlc_length= | |
806 s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; | |
807 } | |
808 | |
809 static inline void encode_dc(MpegEncContext *s, int diff, int component) | |
810 { | |
811 if(((unsigned) (diff+255)) >= 511){ | |
812 int index; | |
813 | |
814 if(diff<0){ | |
815 index= av_log2_16bit(-2*diff); | |
816 diff--; | |
817 }else{ | |
818 index= av_log2_16bit(2*diff); | |
819 } | |
820 if (component == 0) { | |
821 put_bits( | |
822 &s->pb, | |
5210 | 823 ff_mpeg12_vlc_dc_lum_bits[index] + index, |
824 (ff_mpeg12_vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1))); | |
5208 | 825 }else{ |
826 put_bits( | |
827 &s->pb, | |
5210 | 828 ff_mpeg12_vlc_dc_chroma_bits[index] + index, |
829 (ff_mpeg12_vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1))); | |
5208 | 830 } |
831 }else{ | |
832 if (component == 0) { | |
833 put_bits( | |
834 &s->pb, | |
835 mpeg1_lum_dc_uni[diff+255]&0xFF, | |
836 mpeg1_lum_dc_uni[diff+255]>>8); | |
837 } else { | |
838 put_bits( | |
839 &s->pb, | |
840 mpeg1_chr_dc_uni[diff+255]&0xFF, | |
841 mpeg1_chr_dc_uni[diff+255]>>8); | |
842 } | |
843 } | |
844 } | |
845 | |
846 static void mpeg1_encode_block(MpegEncContext *s, | |
847 DCTELEM *block, | |
848 int n) | |
849 { | |
850 int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign; | |
851 int code, component; | |
5210 | 852 const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc; |
5208 | 853 |
854 last_index = s->block_last_index[n]; | |
855 | |
856 /* DC coef */ | |
857 if (s->mb_intra) { | |
858 component = (n <= 3 ? 0 : (n&1) + 1); | |
859 dc = block[0]; /* overflow is impossible */ | |
860 diff = dc - s->last_dc[component]; | |
861 encode_dc(s, diff, component); | |
862 s->last_dc[component] = dc; | |
863 i = 1; | |
864 if (s->intra_vlc_format) | |
5210 | 865 table_vlc = ff_rl_mpeg2.table_vlc; |
5208 | 866 } else { |
867 /* encode the first coefficient : needs to be done here because | |
868 it is handled slightly differently */ | |
869 level = block[0]; | |
870 if (abs(level) == 1) { | |
871 code = ((uint32_t)level >> 31); /* the sign bit */ | |
872 put_bits(&s->pb, 2, code | 0x02); | |
873 i = 1; | |
874 } else { | |
875 i = 0; | |
876 last_non_zero = -1; | |
877 goto next_coef; | |
878 } | |
879 } | |
880 | |
881 /* now quantify & encode AC coefs */ | |
882 last_non_zero = i - 1; | |
883 | |
884 for(;i<=last_index;i++) { | |
885 j = s->intra_scantable.permutated[i]; | |
886 level = block[j]; | |
887 next_coef: | |
888 #if 0 | |
889 if (level != 0) | |
890 dprintf(s->avctx, "level[%d]=%d\n", i, level); | |
891 #endif | |
892 /* encode using VLC */ | |
893 if (level != 0) { | |
894 run = i - last_non_zero - 1; | |
895 | |
896 alevel= level; | |
897 MASK_ABS(sign, alevel) | |
898 sign&=1; | |
899 | |
900 if (alevel <= mpeg1_max_level[0][run]){ | |
901 code= mpeg1_index_run[0][run] + alevel - 1; | |
902 /* store the vlc & sign at once */ | |
903 put_bits(&s->pb, table_vlc[code][1]+1, (table_vlc[code][0]<<1) + sign); | |
904 } else { | |
905 /* escape seems to be pretty rare <5% so I do not optimize it */ | |
906 put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]); | |
907 /* escape: only clip in this case */ | |
908 put_bits(&s->pb, 6, run); | |
909 if(s->codec_id == CODEC_ID_MPEG1VIDEO){ | |
910 if (alevel < 128) { | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
911 put_sbits(&s->pb, 8, level); |
5208 | 912 } else { |
913 if (level < 0) { | |
914 put_bits(&s->pb, 16, 0x8001 + level + 255); | |
915 } else { | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
916 put_sbits(&s->pb, 16, level); |
5208 | 917 } |
918 } | |
919 }else{ | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
920 put_sbits(&s->pb, 12, level); |
5208 | 921 } |
922 } | |
923 last_non_zero = i; | |
924 } | |
925 } | |
926 /* end of block */ | |
927 put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]); | |
928 } | |
929 | |
930 AVCodec mpeg1video_encoder = { | |
931 "mpeg1video", | |
932 CODEC_TYPE_VIDEO, | |
933 CODEC_ID_MPEG1VIDEO, | |
934 sizeof(MpegEncContext), | |
935 encode_init, | |
936 MPV_encode_picture, | |
937 MPV_encode_end, | |
938 .supported_framerates= ff_frame_rate_tab+1, | |
6788 | 939 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
5208 | 940 .capabilities= CODEC_CAP_DELAY, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6788
diff
changeset
|
941 .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"), |
5208 | 942 }; |
943 | |
944 AVCodec mpeg2video_encoder = { | |
945 "mpeg2video", | |
946 CODEC_TYPE_VIDEO, | |
947 CODEC_ID_MPEG2VIDEO, | |
948 sizeof(MpegEncContext), | |
949 encode_init, | |
950 MPV_encode_picture, | |
951 MPV_encode_end, | |
952 .supported_framerates= ff_frame_rate_tab+1, | |
6788 | 953 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE}, |
5208 | 954 .capabilities= CODEC_CAP_DELAY, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6788
diff
changeset
|
955 .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"), |
5208 | 956 }; |