Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4349 | Serge | 1 | /* |
2 | * ITU H263 bitstream encoder |
||
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 |
||
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 | |||
25 | /** |
||
26 | * @file |
||
27 | * h263 bitstream encoder. |
||
28 | */ |
||
29 | |||
30 | #include |
||
31 | |||
32 | #include "libavutil/attributes.h" |
||
33 | #include "avcodec.h" |
||
34 | #include "mpegvideo.h" |
||
35 | #include "h263.h" |
||
36 | #include "mathops.h" |
||
37 | #include "unary.h" |
||
38 | #include "flv.h" |
||
39 | #include "mpeg4video.h" |
||
40 | #include "internal.h" |
||
41 | |||
42 | /** |
||
43 | * Table of number of bits a motion vector component needs. |
||
44 | */ |
||
45 | static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
||
46 | |||
47 | /** |
||
48 | * Minimal fcode that a motion vector component would need. |
||
49 | */ |
||
50 | static uint8_t fcode_tab[MAX_MV*2+1]; |
||
51 | |||
52 | /** |
||
53 | * Minimal fcode that a motion vector component would need in umv. |
||
54 | * All entries in this table are 1. |
||
55 | */ |
||
56 | static uint8_t umv_fcode_tab[MAX_MV*2+1]; |
||
57 | |||
58 | //unified encoding tables for run length encoding of coefficients |
||
59 | //unified in the sense that the specification specifies the encoding in several steps. |
||
60 | static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; |
||
61 | static uint8_t uni_h263_inter_rl_len [64*64*2*2]; |
||
62 | //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level)) |
||
63 | //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
||
64 | #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) |
||
65 | |||
66 | static const uint8_t wrong_run[102] = { |
||
67 | 1, 2, 3, 5, 4, 10, 9, 8, |
||
68 | 11, 15, 17, 16, 23, 22, 21, 20, |
||
69 | 19, 18, 25, 24, 27, 26, 11, 7, |
||
70 | 6, 1, 2, 13, 2, 2, 2, 2, |
||
71 | 6, 12, 3, 9, 1, 3, 4, 3, |
||
72 | 7, 4, 1, 1, 5, 5, 14, 6, |
||
73 | 1, 7, 1, 8, 1, 1, 1, 1, |
||
74 | 10, 1, 1, 5, 9, 17, 25, 24, |
||
75 | 29, 33, 32, 41, 2, 23, 28, 31, |
||
76 | 3, 22, 30, 4, 27, 40, 8, 26, |
||
77 | 6, 39, 7, 38, 16, 37, 15, 10, |
||
78 | 11, 12, 13, 14, 1, 21, 20, 18, |
||
79 | 19, 2, 1, 34, 35, 36 |
||
80 | }; |
||
81 | |||
82 | /** |
||
83 | * Return the 4 bit value that specifies the given aspect ratio. |
||
84 | * This may be one of the standard aspect ratios or it specifies |
||
85 | * that the aspect will be stored explicitly later. |
||
86 | */ |
||
87 | av_const int ff_h263_aspect_to_info(AVRational aspect){ |
||
88 | int i; |
||
89 | |||
90 | if(aspect.num==0) aspect= (AVRational){1,1}; |
||
91 | |||
92 | for(i=1; i<6; i++){ |
||
93 | if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){ |
||
94 | return i; |
||
95 | } |
||
96 | } |
||
97 | |||
98 | return FF_ASPECT_EXTENDED; |
||
99 | } |
||
100 | |||
101 | void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number) |
||
102 | { |
||
103 | int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref; |
||
104 | int best_clock_code=1; |
||
105 | int best_divisor=60; |
||
106 | int best_error= INT_MAX; |
||
107 | |||
108 | if(s->h263_plus){ |
||
109 | for(i=0; i<2; i++){ |
||
110 | int div, error; |
||
111 | div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den); |
||
112 | div= av_clip(div, 1, 127); |
||
113 | error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div); |
||
114 | if(error < best_error){ |
||
115 | best_error= error; |
||
116 | best_divisor= div; |
||
117 | best_clock_code= i; |
||
118 | } |
||
119 | } |
||
120 | } |
||
121 | s->custom_pcf= best_clock_code!=1 || best_divisor!=60; |
||
122 | coded_frame_rate= 1800000; |
||
123 | coded_frame_rate_base= (1000+best_clock_code)*best_divisor; |
||
124 | |||
125 | avpriv_align_put_bits(&s->pb); |
||
126 | |||
127 | /* Update the pointer to last GOB */ |
||
128 | s->ptr_lastgob = put_bits_ptr(&s->pb); |
||
129 | put_bits(&s->pb, 22, 0x20); /* PSC */ |
||
130 | temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp |
||
131 | (coded_frame_rate_base * (int64_t)s->avctx->time_base.den); |
||
132 | put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */ |
||
133 | |||
134 | put_bits(&s->pb, 1, 1); /* marker */ |
||
135 | put_bits(&s->pb, 1, 0); /* h263 id */ |
||
136 | put_bits(&s->pb, 1, 0); /* split screen off */ |
||
137 | put_bits(&s->pb, 1, 0); /* camera off */ |
||
138 | put_bits(&s->pb, 1, 0); /* freeze picture release off */ |
||
139 | |||
140 | format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->width, s->height); |
||
141 | if (!s->h263_plus) { |
||
142 | /* H.263v1 */ |
||
143 | put_bits(&s->pb, 3, format); |
||
144 | put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P)); |
||
145 | /* By now UMV IS DISABLED ON H.263v1, since the restrictions |
||
146 | of H.263v1 UMV implies to check the predicted MV after |
||
147 | calculation of the current MB to see if we're on the limits */ |
||
148 | put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ |
||
149 | put_bits(&s->pb, 1, 0); /* SAC: off */ |
||
150 | put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ |
||
151 | put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ |
||
152 | put_bits(&s->pb, 5, s->qscale); |
||
153 | put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
||
154 | } else { |
||
155 | int ufep=1; |
||
156 | /* H.263v2 */ |
||
157 | /* H.263 Plus PTYPE */ |
||
158 | |||
159 | put_bits(&s->pb, 3, 7); |
||
160 | put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */ |
||
161 | if (format == 8) |
||
162 | put_bits(&s->pb,3,6); /* Custom Source Format */ |
||
163 | else |
||
164 | put_bits(&s->pb, 3, format); |
||
165 | |||
166 | put_bits(&s->pb,1, s->custom_pcf); |
||
167 | put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ |
||
168 | put_bits(&s->pb,1,0); /* SAC: off */ |
||
169 | put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */ |
||
170 | put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
||
171 | put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ |
||
172 | put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ |
||
173 | put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ |
||
174 | put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ |
||
175 | put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ |
||
176 | put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ |
||
177 | put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
||
178 | put_bits(&s->pb,3,0); /* Reserved */ |
||
179 | |||
180 | put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P); |
||
181 | |||
182 | put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ |
||
183 | put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */ |
||
184 | put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
||
185 | put_bits(&s->pb,2,0); /* Reserved */ |
||
186 | put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
||
187 | |||
188 | /* This should be here if PLUSPTYPE */ |
||
189 | put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
||
190 | |||
191 | if (format == 8) { |
||
192 | /* Custom Picture Format (CPFMT) */ |
||
193 | s->aspect_ratio_info= ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio); |
||
194 | |||
195 | put_bits(&s->pb,4,s->aspect_ratio_info); |
||
196 | put_bits(&s->pb,9,(s->width >> 2) - 1); |
||
197 | put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
||
198 | put_bits(&s->pb,9,(s->height >> 2)); |
||
199 | if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
||
200 | put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); |
||
201 | put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); |
||
202 | } |
||
203 | } |
||
204 | if(s->custom_pcf){ |
||
205 | if(ufep){ |
||
206 | put_bits(&s->pb, 1, best_clock_code); |
||
207 | put_bits(&s->pb, 7, best_divisor); |
||
208 | } |
||
209 | put_sbits(&s->pb, 2, temp_ref>>8); |
||
210 | } |
||
211 | |||
212 | /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
||
213 | if (s->umvplus) |
||
214 | // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
||
215 | //FIXME check actual requested range |
||
216 | put_bits(&s->pb,2,1); /* unlimited */ |
||
217 | if(s->h263_slice_structured) |
||
218 | put_bits(&s->pb,2,0); /* no weird submodes */ |
||
219 | |||
220 | put_bits(&s->pb, 5, s->qscale); |
||
221 | } |
||
222 | |||
223 | put_bits(&s->pb, 1, 0); /* no PEI */ |
||
224 | |||
225 | if(s->h263_slice_structured){ |
||
226 | put_bits(&s->pb, 1, 1); |
||
227 | |||
228 | av_assert1(s->mb_x == 0 && s->mb_y == 0); |
||
229 | ff_h263_encode_mba(s); |
||
230 | |||
231 | put_bits(&s->pb, 1, 1); |
||
232 | } |
||
233 | |||
234 | if(s->h263_aic){ |
||
235 | s->y_dc_scale_table= |
||
236 | s->c_dc_scale_table= ff_aic_dc_scale_table; |
||
237 | }else{ |
||
238 | s->y_dc_scale_table= |
||
239 | s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
||
240 | } |
||
241 | } |
||
242 | |||
243 | /** |
||
244 | * Encode a group of blocks header. |
||
245 | */ |
||
246 | void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line) |
||
247 | { |
||
248 | put_bits(&s->pb, 17, 1); /* GBSC */ |
||
249 | |||
250 | if(s->h263_slice_structured){ |
||
251 | put_bits(&s->pb, 1, 1); |
||
252 | |||
253 | ff_h263_encode_mba(s); |
||
254 | |||
255 | if(s->mb_num > 1583) |
||
256 | put_bits(&s->pb, 1, 1); |
||
257 | put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
||
258 | put_bits(&s->pb, 1, 1); |
||
259 | put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */ |
||
260 | }else{ |
||
261 | int gob_number= mb_line / s->gob_index; |
||
262 | |||
263 | put_bits(&s->pb, 5, gob_number); /* GN */ |
||
264 | put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */ |
||
265 | put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
||
266 | } |
||
267 | } |
||
268 | |||
269 | /** |
||
270 | * modify qscale so that encoding is actually possible in h263 (limit difference to -2..2) |
||
271 | */ |
||
272 | void ff_clean_h263_qscales(MpegEncContext *s){ |
||
273 | int i; |
||
274 | int8_t * const qscale_table = s->current_picture.qscale_table; |
||
275 | |||
276 | ff_init_qscale_tab(s); |
||
277 | |||
278 | for(i=1; i |
||
279 | if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2) |
||
280 | qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2; |
||
281 | } |
||
282 | for(i=s->mb_num-2; i>=0; i--){ |
||
283 | if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2) |
||
284 | qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2; |
||
285 | } |
||
286 | |||
287 | if(s->codec_id != AV_CODEC_ID_H263P){ |
||
288 | for(i=1; i |
||
289 | int mb_xy= s->mb_index2xy[i]; |
||
290 | |||
291 | if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ |
||
292 | s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER; |
||
293 | } |
||
294 | } |
||
295 | } |
||
296 | } |
||
297 | |||
298 | static const int dquant_code[5]= {1,0,9,2,3}; |
||
299 | |||
300 | /** |
||
301 | * Encode an 8x8 block. |
||
302 | * @param block the 8x8 block |
||
303 | * @param n block index (0-3 are luma, 4-5 are chroma) |
||
304 | */ |
||
305 | static void h263_encode_block(MpegEncContext * s, int16_t * block, int n) |
||
306 | { |
||
307 | int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code; |
||
308 | RLTable *rl; |
||
309 | |||
310 | rl = &ff_h263_rl_inter; |
||
311 | if (s->mb_intra && !s->h263_aic) { |
||
312 | /* DC coef */ |
||
313 | level = block[0]; |
||
314 | /* 255 cannot be represented, so we clamp */ |
||
315 | if (level > 254) { |
||
316 | level = 254; |
||
317 | block[0] = 254; |
||
318 | } |
||
319 | /* 0 cannot be represented also */ |
||
320 | else if (level < 1) { |
||
321 | level = 1; |
||
322 | block[0] = 1; |
||
323 | } |
||
324 | if (level == 128) //FIXME check rv10 |
||
325 | put_bits(&s->pb, 8, 0xff); |
||
326 | else |
||
327 | put_bits(&s->pb, 8, level); |
||
328 | i = 1; |
||
329 | } else { |
||
330 | i = 0; |
||
331 | if (s->h263_aic && s->mb_intra) |
||
332 | rl = &ff_rl_intra_aic; |
||
333 | |||
334 | if(s->alt_inter_vlc && !s->mb_intra){ |
||
335 | int aic_vlc_bits=0; |
||
336 | int inter_vlc_bits=0; |
||
337 | int wrong_pos=-1; |
||
338 | int aic_code; |
||
339 | |||
340 | last_index = s->block_last_index[n]; |
||
341 | last_non_zero = i - 1; |
||
342 | for (; i <= last_index; i++) { |
||
343 | j = s->intra_scantable.permutated[i]; |
||
344 | level = block[j]; |
||
345 | if (level) { |
||
346 | run = i - last_non_zero - 1; |
||
347 | last = (i == last_index); |
||
348 | |||
349 | if(level<0) level= -level; |
||
350 | |||
351 | code = get_rl_index(rl, last, run, level); |
||
352 | aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level); |
||
353 | inter_vlc_bits += rl->table_vlc[code][1]+1; |
||
354 | aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1; |
||
355 | |||
356 | if (code == rl->n) { |
||
357 | inter_vlc_bits += 1+6+8-1; |
||
358 | } |
||
359 | if (aic_code == ff_rl_intra_aic.n) { |
||
360 | aic_vlc_bits += 1+6+8-1; |
||
361 | wrong_pos += run + 1; |
||
362 | }else |
||
363 | wrong_pos += wrong_run[aic_code]; |
||
364 | last_non_zero = i; |
||
365 | } |
||
366 | } |
||
367 | i = 0; |
||
368 | if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) |
||
369 | rl = &ff_rl_intra_aic; |
||
370 | } |
||
371 | } |
||
372 | |||
373 | /* AC coefs */ |
||
374 | last_index = s->block_last_index[n]; |
||
375 | last_non_zero = i - 1; |
||
376 | for (; i <= last_index; i++) { |
||
377 | j = s->intra_scantable.permutated[i]; |
||
378 | level = block[j]; |
||
379 | if (level) { |
||
380 | run = i - last_non_zero - 1; |
||
381 | last = (i == last_index); |
||
382 | sign = 0; |
||
383 | slevel = level; |
||
384 | if (level < 0) { |
||
385 | sign = 1; |
||
386 | level = -level; |
||
387 | } |
||
388 | code = get_rl_index(rl, last, run, level); |
||
389 | put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
||
390 | if (code == rl->n) { |
||
391 | if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){ |
||
392 | put_bits(&s->pb, 1, last); |
||
393 | put_bits(&s->pb, 6, run); |
||
394 | |||
395 | av_assert2(slevel != 0); |
||
396 | |||
397 | if(level < 128) |
||
398 | put_sbits(&s->pb, 8, slevel); |
||
399 | else{ |
||
400 | put_bits(&s->pb, 8, 128); |
||
401 | put_sbits(&s->pb, 5, slevel); |
||
402 | put_sbits(&s->pb, 6, slevel>>5); |
||
403 | } |
||
404 | }else{ |
||
405 | ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last); |
||
406 | } |
||
407 | } else { |
||
408 | put_bits(&s->pb, 1, sign); |
||
409 | } |
||
410 | last_non_zero = i; |
||
411 | } |
||
412 | } |
||
413 | } |
||
414 | |||
415 | /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
||
416 | static void h263p_encode_umotion(MpegEncContext * s, int val) |
||
417 | { |
||
418 | short sval = 0; |
||
419 | short i = 0; |
||
420 | short n_bits = 0; |
||
421 | short temp_val; |
||
422 | int code = 0; |
||
423 | int tcode; |
||
424 | |||
425 | if ( val == 0) |
||
426 | put_bits(&s->pb, 1, 1); |
||
427 | else if (val == 1) |
||
428 | put_bits(&s->pb, 3, 0); |
||
429 | else if (val == -1) |
||
430 | put_bits(&s->pb, 3, 2); |
||
431 | else { |
||
432 | |||
433 | sval = ((val < 0) ? (short)(-val):(short)val); |
||
434 | temp_val = sval; |
||
435 | |||
436 | while (temp_val != 0) { |
||
437 | temp_val = temp_val >> 1; |
||
438 | n_bits++; |
||
439 | } |
||
440 | |||
441 | i = n_bits - 1; |
||
442 | while (i > 0) { |
||
443 | tcode = (sval & (1 << (i-1))) >> (i-1); |
||
444 | tcode = (tcode << 1) | 1; |
||
445 | code = (code << 2) | tcode; |
||
446 | i--; |
||
447 | } |
||
448 | code = ((code << 1) | (val < 0)) << 1; |
||
449 | put_bits(&s->pb, (2*n_bits)+1, code); |
||
450 | } |
||
451 | } |
||
452 | |||
453 | void ff_h263_encode_mb(MpegEncContext * s, |
||
454 | int16_t block[6][64], |
||
455 | int motion_x, int motion_y) |
||
456 | { |
||
457 | int cbpc, cbpy, i, cbp, pred_x, pred_y; |
||
458 | int16_t pred_dc; |
||
459 | int16_t rec_intradc[6]; |
||
460 | int16_t *dc_ptr[6]; |
||
461 | const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
||
462 | |||
463 | if (!s->mb_intra) { |
||
464 | /* compute cbp */ |
||
465 | cbp= get_p_cbp(s, block, motion_x, motion_y); |
||
466 | |||
467 | if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) { |
||
468 | /* skip macroblock */ |
||
469 | put_bits(&s->pb, 1, 1); |
||
470 | if(interleaved_stats){ |
||
471 | s->misc_bits++; |
||
472 | s->last_bits++; |
||
473 | } |
||
474 | s->skip_count++; |
||
475 | |||
476 | return; |
||
477 | } |
||
478 | put_bits(&s->pb, 1, 0); /* mb coded */ |
||
479 | |||
480 | cbpc = cbp & 3; |
||
481 | cbpy = cbp >> 2; |
||
482 | if(s->alt_inter_vlc==0 || cbpc!=3) |
||
483 | cbpy ^= 0xF; |
||
484 | if(s->dquant) cbpc+= 8; |
||
485 | if(s->mv_type==MV_TYPE_16X16){ |
||
486 | put_bits(&s->pb, |
||
487 | ff_h263_inter_MCBPC_bits[cbpc], |
||
488 | ff_h263_inter_MCBPC_code[cbpc]); |
||
489 | |||
490 | put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]); |
||
491 | if(s->dquant) |
||
492 | put_bits(&s->pb, 2, dquant_code[s->dquant+2]); |
||
493 | |||
494 | if(interleaved_stats){ |
||
495 | s->misc_bits+= get_bits_diff(s); |
||
496 | } |
||
497 | |||
498 | /* motion vectors: 16x16 mode */ |
||
499 | ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
||
500 | |||
501 | if (!s->umvplus) { |
||
502 | ff_h263_encode_motion_vector(s, motion_x - pred_x, |
||
503 | motion_y - pred_y, 1); |
||
504 | } |
||
505 | else { |
||
506 | h263p_encode_umotion(s, motion_x - pred_x); |
||
507 | h263p_encode_umotion(s, motion_y - pred_y); |
||
508 | if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) |
||
509 | /* To prevent Start Code emulation */ |
||
510 | put_bits(&s->pb,1,1); |
||
511 | } |
||
512 | }else{ |
||
513 | put_bits(&s->pb, |
||
514 | ff_h263_inter_MCBPC_bits[cbpc+16], |
||
515 | ff_h263_inter_MCBPC_code[cbpc+16]); |
||
516 | put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]); |
||
517 | if(s->dquant) |
||
518 | put_bits(&s->pb, 2, dquant_code[s->dquant+2]); |
||
519 | |||
520 | if(interleaved_stats){ |
||
521 | s->misc_bits+= get_bits_diff(s); |
||
522 | } |
||
523 | |||
524 | for(i=0; i<4; i++){ |
||
525 | /* motion vectors: 8x8 mode*/ |
||
526 | ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
||
527 | |||
528 | motion_x = s->current_picture.motion_val[0][s->block_index[i]][0]; |
||
529 | motion_y = s->current_picture.motion_val[0][s->block_index[i]][1]; |
||
530 | if (!s->umvplus) { |
||
531 | ff_h263_encode_motion_vector(s, motion_x - pred_x, |
||
532 | motion_y - pred_y, 1); |
||
533 | } |
||
534 | else { |
||
535 | h263p_encode_umotion(s, motion_x - pred_x); |
||
536 | h263p_encode_umotion(s, motion_y - pred_y); |
||
537 | if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) |
||
538 | /* To prevent Start Code emulation */ |
||
539 | put_bits(&s->pb,1,1); |
||
540 | } |
||
541 | } |
||
542 | } |
||
543 | |||
544 | if(interleaved_stats){ |
||
545 | s->mv_bits+= get_bits_diff(s); |
||
546 | } |
||
547 | } else { |
||
548 | av_assert2(s->mb_intra); |
||
549 | |||
550 | cbp = 0; |
||
551 | if (s->h263_aic) { |
||
552 | /* Predict DC */ |
||
553 | for(i=0; i<6; i++) { |
||
554 | int16_t level = block[i][0]; |
||
555 | int scale; |
||
556 | |||
557 | if(i<4) scale= s->y_dc_scale; |
||
558 | else scale= s->c_dc_scale; |
||
559 | |||
560 | pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]); |
||
561 | level -= pred_dc; |
||
562 | /* Quant */ |
||
563 | if (level >= 0) |
||
564 | level = (level + (scale>>1))/scale; |
||
565 | else |
||
566 | level = (level - (scale>>1))/scale; |
||
567 | |||
568 | /* AIC can change CBP */ |
||
569 | if (level == 0 && s->block_last_index[i] == 0) |
||
570 | s->block_last_index[i] = -1; |
||
571 | |||
572 | if(!s->modified_quant){ |
||
573 | if (level < -127) |
||
574 | level = -127; |
||
575 | else if (level > 127) |
||
576 | level = 127; |
||
577 | } |
||
578 | |||
579 | block[i][0] = level; |
||
580 | /* Reconstruction */ |
||
581 | rec_intradc[i] = scale*level + pred_dc; |
||
582 | /* Oddify */ |
||
583 | rec_intradc[i] |= 1; |
||
584 | //if ((rec_intradc[i] % 2) == 0) |
||
585 | // rec_intradc[i]++; |
||
586 | /* Clipping */ |
||
587 | if (rec_intradc[i] < 0) |
||
588 | rec_intradc[i] = 0; |
||
589 | else if (rec_intradc[i] > 2047) |
||
590 | rec_intradc[i] = 2047; |
||
591 | |||
592 | /* Update AC/DC tables */ |
||
593 | *dc_ptr[i] = rec_intradc[i]; |
||
594 | if (s->block_last_index[i] >= 0) |
||
595 | cbp |= 1 << (5 - i); |
||
596 | } |
||
597 | }else{ |
||
598 | for(i=0; i<6; i++) { |
||
599 | /* compute cbp */ |
||
600 | if (s->block_last_index[i] >= 1) |
||
601 | cbp |= 1 << (5 - i); |
||
602 | } |
||
603 | } |
||
604 | |||
605 | cbpc = cbp & 3; |
||
606 | if (s->pict_type == AV_PICTURE_TYPE_I) { |
||
607 | if(s->dquant) cbpc+=4; |
||
608 | put_bits(&s->pb, |
||
609 | ff_h263_intra_MCBPC_bits[cbpc], |
||
610 | ff_h263_intra_MCBPC_code[cbpc]); |
||
611 | } else { |
||
612 | if(s->dquant) cbpc+=8; |
||
613 | put_bits(&s->pb, 1, 0); /* mb coded */ |
||
614 | put_bits(&s->pb, |
||
615 | ff_h263_inter_MCBPC_bits[cbpc + 4], |
||
616 | ff_h263_inter_MCBPC_code[cbpc + 4]); |
||
617 | } |
||
618 | if (s->h263_aic) { |
||
619 | /* XXX: currently, we do not try to use ac prediction */ |
||
620 | put_bits(&s->pb, 1, 0); /* no AC prediction */ |
||
621 | } |
||
622 | cbpy = cbp >> 2; |
||
623 | put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]); |
||
624 | if(s->dquant) |
||
625 | put_bits(&s->pb, 2, dquant_code[s->dquant+2]); |
||
626 | |||
627 | if(interleaved_stats){ |
||
628 | s->misc_bits+= get_bits_diff(s); |
||
629 | } |
||
630 | } |
||
631 | |||
632 | for(i=0; i<6; i++) { |
||
633 | /* encode each block */ |
||
634 | h263_encode_block(s, block[i], i); |
||
635 | |||
636 | /* Update INTRADC for decoding */ |
||
637 | if (s->h263_aic && s->mb_intra) { |
||
638 | block[i][0] = rec_intradc[i]; |
||
639 | |||
640 | } |
||
641 | } |
||
642 | |||
643 | if(interleaved_stats){ |
||
644 | if (!s->mb_intra) { |
||
645 | s->p_tex_bits+= get_bits_diff(s); |
||
646 | s->f_count++; |
||
647 | }else{ |
||
648 | s->i_tex_bits+= get_bits_diff(s); |
||
649 | s->i_count++; |
||
650 | } |
||
651 | } |
||
652 | } |
||
653 | |||
654 | void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) |
||
655 | { |
||
656 | int range, bit_size, sign, code, bits; |
||
657 | |||
658 | if (val == 0) { |
||
659 | /* zero vector */ |
||
660 | code = 0; |
||
661 | put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]); |
||
662 | } else { |
||
663 | bit_size = f_code - 1; |
||
664 | range = 1 << bit_size; |
||
665 | /* modulo encoding */ |
||
666 | val = sign_extend(val, 6 + bit_size); |
||
667 | sign = val>>31; |
||
668 | val= (val^sign)-sign; |
||
669 | sign&=1; |
||
670 | |||
671 | val--; |
||
672 | code = (val >> bit_size) + 1; |
||
673 | bits = val & (range - 1); |
||
674 | |||
675 | put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign); |
||
676 | if (bit_size > 0) { |
||
677 | put_bits(&s->pb, bit_size, bits); |
||
678 | } |
||
679 | } |
||
680 | } |
||
681 | |||
682 | static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s) |
||
683 | { |
||
684 | int f_code; |
||
685 | int mv; |
||
686 | |||
687 | for(f_code=1; f_code<=MAX_FCODE; f_code++){ |
||
688 | for(mv=-MAX_MV; mv<=MAX_MV; mv++){ |
||
689 | int len; |
||
690 | |||
691 | if(mv==0) len= ff_mvtab[0][1]; |
||
692 | else{ |
||
693 | int val, bit_size, code; |
||
694 | |||
695 | bit_size = f_code - 1; |
||
696 | |||
697 | val=mv; |
||
698 | if (val < 0) |
||
699 | val = -val; |
||
700 | val--; |
||
701 | code = (val >> bit_size) + 1; |
||
702 | if(code<33){ |
||
703 | len= ff_mvtab[code][1] + 1 + bit_size; |
||
704 | }else{ |
||
705 | len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size; |
||
706 | } |
||
707 | } |
||
708 | |||
709 | mv_penalty[f_code][mv+MAX_MV]= len; |
||
710 | } |
||
711 | } |
||
712 | |||
713 | for(f_code=MAX_FCODE; f_code>0; f_code--){ |
||
714 | for(mv=-(16< |
||
715 | fcode_tab[mv+MAX_MV]= f_code; |
||
716 | } |
||
717 | } |
||
718 | |||
719 | for(mv=0; mv |
||
720 | umv_fcode_tab[mv]= 1; |
||
721 | } |
||
722 | } |
||
723 | |||
724 | static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, |
||
725 | uint8_t *len_tab) |
||
726 | { |
||
727 | int slevel, run, last; |
||
728 | |||
729 | av_assert0(MAX_LEVEL >= 64); |
||
730 | av_assert0(MAX_RUN >= 63); |
||
731 | |||
732 | for(slevel=-64; slevel<64; slevel++){ |
||
733 | if(slevel==0) continue; |
||
734 | for(run=0; run<64; run++){ |
||
735 | for(last=0; last<=1; last++){ |
||
736 | const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); |
||
737 | int level= slevel < 0 ? -slevel : slevel; |
||
738 | int sign= slevel < 0 ? 1 : 0; |
||
739 | int bits, len, code; |
||
740 | |||
741 | len_tab[index]= 100; |
||
742 | |||
743 | /* ESC0 */ |
||
744 | code= get_rl_index(rl, last, run, level); |
||
745 | bits= rl->table_vlc[code][0]; |
||
746 | len= rl->table_vlc[code][1]; |
||
747 | bits=bits*2+sign; len++; |
||
748 | |||
749 | if(code!=rl->n && len < len_tab[index]){ |
||
750 | if(bits_tab) bits_tab[index]= bits; |
||
751 | len_tab [index]= len; |
||
752 | } |
||
753 | /* ESC */ |
||
754 | bits= rl->table_vlc[rl->n][0]; |
||
755 | len = rl->table_vlc[rl->n][1]; |
||
756 | bits=bits*2+last; len++; |
||
757 | bits=bits*64+run; len+=6; |
||
758 | bits=bits*256+(level&0xff); len+=8; |
||
759 | |||
760 | if(len < len_tab[index]){ |
||
761 | if(bits_tab) bits_tab[index]= bits; |
||
762 | len_tab [index]= len; |
||
763 | } |
||
764 | } |
||
765 | } |
||
766 | } |
||
767 | } |
||
768 | |||
769 | av_cold void ff_h263_encode_init(MpegEncContext *s) |
||
770 | { |
||
771 | static int done = 0; |
||
772 | |||
773 | if (!done) { |
||
774 | done = 1; |
||
775 | |||
776 | ff_init_rl(&ff_h263_rl_inter, ff_h263_static_rl_table_store[0]); |
||
777 | ff_init_rl(&ff_rl_intra_aic, ff_h263_static_rl_table_store[1]); |
||
778 | |||
779 | init_uni_h263_rl_tab(&ff_rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); |
||
780 | init_uni_h263_rl_tab(&ff_h263_rl_inter , NULL, uni_h263_inter_rl_len); |
||
781 | |||
782 | init_mv_penalty_and_fcode(s); |
||
783 | } |
||
784 | s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p |
||
785 | |||
786 | s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len; |
||
787 | s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; |
||
788 | if(s->h263_aic){ |
||
789 | s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len; |
||
790 | s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; |
||
791 | } |
||
792 | s->ac_esc_length= 7+1+6+8; |
||
793 | |||
794 | // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
||
795 | switch(s->codec_id){ |
||
796 | case AV_CODEC_ID_MPEG4: |
||
797 | s->fcode_tab= fcode_tab; |
||
798 | break; |
||
799 | case AV_CODEC_ID_H263P: |
||
800 | if(s->umvplus) |
||
801 | s->fcode_tab= umv_fcode_tab; |
||
802 | if(s->modified_quant){ |
||
803 | s->min_qcoeff= -2047; |
||
804 | s->max_qcoeff= 2047; |
||
805 | }else{ |
||
806 | s->min_qcoeff= -127; |
||
807 | s->max_qcoeff= 127; |
||
808 | } |
||
809 | break; |
||
810 | //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later |
||
811 | case AV_CODEC_ID_FLV1: |
||
812 | if (s->h263_flv > 1) { |
||
813 | s->min_qcoeff= -1023; |
||
814 | s->max_qcoeff= 1023; |
||
815 | } else { |
||
816 | s->min_qcoeff= -127; |
||
817 | s->max_qcoeff= 127; |
||
818 | } |
||
819 | s->y_dc_scale_table= |
||
820 | s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
||
821 | break; |
||
822 | default: //nothing needed - default table already set in mpegvideo.c |
||
823 | s->min_qcoeff= -127; |
||
824 | s->max_qcoeff= 127; |
||
825 | s->y_dc_scale_table= |
||
826 | s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
||
827 | } |
||
828 | } |
||
829 | |||
830 | void ff_h263_encode_mba(MpegEncContext *s) |
||
831 | { |
||
832 | int i, mb_pos; |
||
833 | |||
834 | for(i=0; i<6; i++){ |
||
835 | if(s->mb_num-1 <= ff_mba_max[i]) break; |
||
836 | } |
||
837 | mb_pos= s->mb_x + s->mb_width*s->mb_y; |
||
838 | put_bits(&s->pb, ff_mba_length[i], mb_pos); |
||
839 | }=>6;>>>>>=1;>64;>64;> |