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