FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/ituh263enc.c
Date: 2025-06-01 09:29:47
Exec Total Coverage
Lines: 413 477 86.6%
Functions: 16 16 100.0%
Branches: 221 281 78.6%
Line Branch Exec Source
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 "config_components.h"
31
32 #include <limits.h>
33 #include <string.h>
34
35 #include "libavutil/attributes.h"
36 #include "libavutil/thread.h"
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "mpegvideo.h"
40 #include "flvenc.h"
41 #include "mpegvideoenc.h"
42 #include "h263.h"
43 #include "h263enc.h"
44 #include "h263data.h"
45 #include "h263dsp.h"
46 #include "mathops.h"
47 #include "mpegutils.h"
48 #include "internal.h"
49 #include "put_bits.h"
50
51 /**
52 * Table of number of bits a motion vector component needs.
53 */
54 static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];
55
56 /**
57 * Minimal fcode that a motion vector component would need in umv.
58 * All entries in this table are 1.
59 */
60 static uint8_t umv_fcode_tab[MAX_MV*2+1];
61
62 //unified encoding tables for run length encoding of coefficients
63 //unified in the sense that the specification specifies the encoding in several steps.
64 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
65 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
66 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
67 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
68 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
69
70 118 static av_cold void init_mv_penalty_and_fcode(void)
71 {
72
2/2
✓ Branch 0 taken 826 times.
✓ Branch 1 taken 118 times.
 944 for (int f_code = 1; f_code <= MAX_FCODE; f_code++) {
73
2/2
✓ Branch 0 taken 13534010 times.
✓ Branch 1 taken 826 times.
 13534836 for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
74 int len;
75
76
2/2
✓ Branch 0 taken 826 times.
✓ Branch 1 taken 13533184 times.
 13534010 if (mv == 0) len = 1; // ff_mvtab[0][1]
77 else {
78 int val, bit_size, code;
79
80 13533184 bit_size = f_code - 1;
81
82 13533184 val = mv;
83
2/2
✓ Branch 0 taken 6766592 times.
✓ Branch 1 taken 6766592 times.
 13533184 if (val < 0)
84 6766592 val = -val;
85 13533184 val--;
86 13533184 code = (val >> bit_size) + 1;
87
2/2
✓ Branch 0 taken 959104 times.
✓ Branch 1 taken 12574080 times.
 13533184 if (code < 33) {
88 959104 len = ff_mvtab[code][1] + 1 + bit_size;
89 } else {
90 12574080 len = 12 /* ff_mvtab[32][1] */ + av_log2(code>>5) + 2 + bit_size;
91 }
92 }
93
94 13534010 mv_penalty[f_code][mv + MAX_DMV] = len;
95 }
96 }
97
98 118 memset(umv_fcode_tab, 1, sizeof(umv_fcode_tab));
99 118 }
100
101 236 static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
102 {
103 av_assert0(MAX_LEVEL >= 64);
104 av_assert0(MAX_RUN >= 63);
105
106
2/2
✓ Branch 0 taken 30208 times.
✓ Branch 1 taken 236 times.
 30444 for (int slevel = -64; slevel < 64; slevel++) {
107
2/2
✓ Branch 0 taken 236 times.
✓ Branch 1 taken 29972 times.
 30208 if (slevel == 0) continue;
108
2/2
✓ Branch 0 taken 1918208 times.
✓ Branch 1 taken 29972 times.
 1948180 for (int run = 0; run < 64; run++) {
109
2/2
✓ Branch 0 taken 3836416 times.
✓ Branch 1 taken 1918208 times.
 5754624 for (int last = 0; last <= 1; last++) {
110 3836416 const int index = UNI_MPEG4_ENC_INDEX(last, run, slevel + 64);
111 3836416 int level = slevel < 0 ? -slevel : slevel;
112 3836416 int sign = slevel < 0 ? 1 : 0;
113 int bits, len, code;
114
115 3836416 len_tab[index] = 100;
116
117 /* ESC0 */
118 3836416 code = get_rl_index(rl, last, run, level);
119 3836416 bits = rl->table_vlc[code][0];
120 3836416 len = rl->table_vlc[code][1];
121 3836416 bits = bits * 2 + sign;
122 3836416 len++;
123
124
3/4
✓ Branch 0 taken 48144 times.
✓ Branch 1 taken 3788272 times.
✓ Branch 2 taken 48144 times.
✗ Branch 3 not taken.
 3836416 if (code != rl->n && len < len_tab[index])
125 48144 len_tab[index] = len;
126
127 /* ESC */
128 3836416 bits = rl->table_vlc[rl->n][0];
129 3836416 len = rl->table_vlc[rl->n][1];
130 3836416 bits = bits * 2 + last; len++;
131 3836416 bits = bits * 64 + run; len += 6;
132 3836416 bits = bits * 256 + (level & 0xff); len += 8;
133
134
2/2
✓ Branch 0 taken 3788272 times.
✓ Branch 1 taken 48144 times.
 3836416 if (len < len_tab[index])
135 3788272 len_tab[index] = len;
136 }
137 }
138 }
139 236 }
140
141 118 static av_cold void h263_encode_init_static(void)
142 {
143 static uint8_t rl_intra_table[2][2 * MAX_RUN + MAX_LEVEL + 3];
144
145 118 ff_rl_init(&ff_rl_intra_aic, rl_intra_table);
146 118 ff_h263_init_rl_inter();
147
148 118 init_uni_h263_rl_tab(&ff_rl_intra_aic, uni_h263_intra_aic_rl_len);
149 118 init_uni_h263_rl_tab(&ff_h263_rl_inter, uni_h263_inter_rl_len);
150
151 118 init_mv_penalty_and_fcode();
152 118 }
153
154 118 av_cold const uint8_t (*ff_h263_get_mv_penalty(void))[MAX_DMV*2+1]
155 {
156 static AVOnce init_static_once = AV_ONCE_INIT;
157
158 118 ff_thread_once(&init_static_once, h263_encode_init_static);
159
160 118 return mv_penalty;
161 }
162
163 5426130 void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
164 {
165
2/2
✓ Branch 0 taken 2264719 times.
✓ Branch 1 taken 3161411 times.
 5426130 if (val == 0) {
166 /* zero vector -- corresponds to ff_mvtab[0] */
167 2264719 put_bits(pb, 1, 1);
168 } else {
169 int sign, code, bits;
170 3161411 int bit_size = f_code - 1;
171 3161411 int range = 1 << bit_size;
172 /* modulo encoding */
173 3161411 val = sign_extend(val, 6 + bit_size);
174 3161411 sign = val>>31;
175 3161411 val= (val^sign)-sign;
176 3161411 sign&=1;
177
178 3161411 val--;
179 3161411 code = (val >> bit_size) + 1;
180 3161411 bits = val & (range - 1);
181
182 3161411 put_bits(pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
183
2/2
✓ Branch 0 taken 367240 times.
✓ Branch 1 taken 2794171 times.
 3161411 if (bit_size > 0) {
184 367240 put_bits(pb, bit_size, bits);
185 }
186 }
187 5426130 }
188
189 #if CONFIG_H263_ENCODER // Snow and SVQ1 need the above
190 static const uint8_t wrong_run[102] = {
191 1, 2, 3, 5, 4, 10, 9, 8,
192 11, 15, 17, 16, 23, 22, 21, 20,
193 19, 18, 25, 24, 27, 26, 11, 7,
194 6, 1, 2, 13, 2, 2, 2, 2,
195 6, 12, 3, 9, 1, 3, 4, 3,
196 7, 4, 1, 1, 5, 5, 14, 6,
197 1, 7, 1, 8, 1, 1, 1, 1,
198 10, 1, 1, 5, 9, 17, 25, 24,
199 29, 33, 32, 41, 2, 23, 28, 31,
200 3, 22, 30, 4, 27, 40, 8, 26,
201 6, 39, 7, 38, 16, 37, 15, 10,
202 11, 12, 13, 14, 1, 21, 20, 18,
203 19, 2, 1, 34, 35, 36
204 };
205
206 /**
207 * Return the 4 bit value that specifies the given aspect ratio.
208 * This may be one of the standard aspect ratios or it specifies
209 * that the aspect will be stored explicitly later.
210 */
211 222 av_const int ff_h263_aspect_to_info(AVRational aspect){
212 int i;
213
214
3/4
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 213 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
 222 if(aspect.num==0 || aspect.den==0) aspect= (AVRational){1,1};
215
216
1/2
✓ Branch 0 taken 222 times.
✗ Branch 1 not taken.
 222 for(i=1; i<6; i++){
217
1/2
✓ Branch 1 taken 222 times.
✗ Branch 2 not taken.
 222 if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
218 222 return i;
219 }
220 }
221
222 ✗ return FF_ASPECT_EXTENDED;
223 }
224
225 450 static int h263_encode_picture_header(MPVMainEncContext *const m)
226 {
227 450 MPVEncContext *const s = &m->s;
228 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
229 450 int best_clock_code=1;
230 450 int best_divisor=60;
231 450 int best_error= INT_MAX;
232 int custom_pcf;
233
234 450 put_bits_assume_flushed(&s->pb);
235
236
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 300 times.
 450 if (s->c.codec_id == AV_CODEC_ID_H263P) {
237
2/2
✓ Branch 0 taken 300 times.
✓ Branch 1 taken 150 times.
 450 for(i=0; i<2; i++){
238 int div, error;
239 300 div= (s->c.avctx->time_base.num*1800000LL + 500LL*s->c.avctx->time_base.den) / ((1000LL+i)*s->c.avctx->time_base.den);
240 300 div= av_clip(div, 1, 127);
241
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 150 times.
 300 error= FFABS(s->c.avctx->time_base.num*1800000LL - (1000LL+i)*s->c.avctx->time_base.den*div);
242
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 150 times.
 300 if(error < best_error){
243 150 best_error= error;
244 150 best_divisor= div;
245 150 best_clock_code= i;
246 }
247 }
248 }
249
3/4
✓ Branch 0 taken 300 times.
✓ Branch 1 taken 150 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 300 times.
 450 custom_pcf = best_clock_code != 1 || best_divisor != 60;
250 450 coded_frame_rate= 1800000;
251 450 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
252
253 450 put_bits(&s->pb, 22, 0x20); /* PSC */
254 450 temp_ref= s->c.picture_number * (int64_t)coded_frame_rate * s->c.avctx->time_base.num / //FIXME use timestamp
255 450 (coded_frame_rate_base * (int64_t)s->c.avctx->time_base.den);
256 450 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
257
258 450 put_bits(&s->pb, 1, 1); /* marker */
259 450 put_bits(&s->pb, 1, 0); /* H.263 id */
260 450 put_bits(&s->pb, 1, 0); /* split screen off */
261 450 put_bits(&s->pb, 1, 0); /* camera off */
262 450 put_bits(&s->pb, 1, 0); /* freeze picture release off */
263
264 450 format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->c.width, s->c.height);
265
2/2
✓ Branch 0 taken 300 times.
✓ Branch 1 taken 150 times.
 450 if (s->c.codec_id != AV_CODEC_ID_H263P) {
266 /* H.263v1 */
267 300 put_bits(&s->pb, 3, format);
268 300 put_bits(&s->pb, 1, (s->c.pict_type == AV_PICTURE_TYPE_P));
269 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
270 of H.263v1 UMV implies to check the predicted MV after
271 calculation of the current MB to see if we're on the limits */
272 300 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
273 300 put_bits(&s->pb, 1, 0); /* SAC: off */
274 300 put_bits(&s->pb, 1, s->c.obmc); /* Advanced Prediction */
275 300 put_bits(&s->pb, 1, 0); /* only I/P-frames, no PB-frame */
276 300 put_bits(&s->pb, 5, s->c.qscale);
277 300 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
278 } else {
279 150 int ufep=1;
280 /* H.263v2 */
281 /* H.263 Plus PTYPE */
282
283 150 put_bits(&s->pb, 3, 7);
284 150 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
285
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 150 times.
 150 if (format == 8)
286 ✗ put_bits(&s->pb,3,6); /* Custom Source Format */
287 else
288 150 put_bits(&s->pb, 3, format);
289
290 150 put_bits(&s->pb,1, custom_pcf);
291 150 put_bits(&s->pb,1, s->c.umvplus); /* Unrestricted Motion Vector */
292 150 put_bits(&s->pb,1,0); /* SAC: off */
293 150 put_bits(&s->pb,1,s->c.obmc); /* Advanced Prediction Mode */
294 150 put_bits(&s->pb,1,s->c.h263_aic); /* Advanced Intra Coding */
295 150 put_bits(&s->pb,1,s->c.loop_filter); /* Deblocking Filter */
296 150 put_bits(&s->pb,1,s->c.h263_slice_structured); /* Slice Structured */
297 150 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
298 150 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
299 150 put_bits(&s->pb,1,s->c.alt_inter_vlc); /* Alternative Inter VLC */
300 150 put_bits(&s->pb,1,s->c.modified_quant); /* Modified Quantization: */
301 150 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
302 150 put_bits(&s->pb,3,0); /* Reserved */
303
304 150 put_bits(&s->pb, 3, s->c.pict_type == AV_PICTURE_TYPE_P);
305
306 150 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
307 150 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
308 150 put_bits(&s->pb,1,s->c.no_rounding); /* Rounding Type */
309 150 put_bits(&s->pb,2,0); /* Reserved */
310 150 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
311
312 /* This should be here if PLUSPTYPE */
313 150 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
314
315
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 150 times.
 150 if (format == 8) {
316 /* Custom Picture Format (CPFMT) */
317 ✗ unsigned aspect_ratio_info = ff_h263_aspect_to_info(s->c.avctx->sample_aspect_ratio);
318
319 ✗ put_bits(&s->pb,4, aspect_ratio_info);
320 ✗ put_bits(&s->pb,9,(s->c.width >> 2) - 1);
321 ✗ put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
322 ✗ put_bits(&s->pb,9,(s->c.height >> 2));
323 ✗ if (aspect_ratio_info == FF_ASPECT_EXTENDED){
324 ✗ put_bits(&s->pb, 8, s->c.avctx->sample_aspect_ratio.num);
325 ✗ put_bits(&s->pb, 8, s->c.avctx->sample_aspect_ratio.den);
326 }
327 }
328
1/2
✓ Branch 0 taken 150 times.
✗ Branch 1 not taken.
 150 if (custom_pcf) {
329
1/2
✓ Branch 0 taken 150 times.
✗ Branch 1 not taken.
 150 if(ufep){
330 150 put_bits(&s->pb, 1, best_clock_code);
331 150 put_bits(&s->pb, 7, best_divisor);
332 }
333 150 put_sbits(&s->pb, 2, temp_ref>>8);
334 }
335
336 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
337
1/2
✓ Branch 0 taken 150 times.
✗ Branch 1 not taken.
 150 if (s->c.umvplus)
338 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
339 //FIXME check actual requested range
340 150 put_bits(&s->pb,2,1); /* unlimited */
341
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 150 times.
 150 if(s->c.h263_slice_structured)
342 ✗ put_bits(&s->pb,2,0); /* no weird submodes */
343
344 150 put_bits(&s->pb, 5, s->c.qscale);
345 }
346
347 450 put_bits(&s->pb, 1, 0); /* no PEI */
348
349
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 450 times.
 450 if(s->c.h263_slice_structured){
350 ✗ put_bits(&s->pb, 1, 1);
351
352 av_assert1(s->c.mb_x == 0 && s->c.mb_y == 0);
353 ✗ ff_h263_encode_mba(s);
354
355 ✗ put_bits(&s->pb, 1, 1);
356 }
357
358 450 return 0;
359 }
360
361 /**
362 * Encode a group of blocks header.
363 */
364 2544 void ff_h263_encode_gob_header(MPVEncContext *const s, int mb_line)
365 {
366 2544 put_bits(&s->pb, 17, 1); /* GBSC */
367
368
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2544 times.
 2544 if(s->c.h263_slice_structured){
369 ✗ put_bits(&s->pb, 1, 1);
370
371 ✗ ff_h263_encode_mba(s);
372
373 ✗ if(s->c.mb_num > 1583)
374 ✗ put_bits(&s->pb, 1, 1);
375 ✗ put_bits(&s->pb, 5, s->c.qscale); /* GQUANT */
376 ✗ put_bits(&s->pb, 1, 1);
377 ✗ put_bits(&s->pb, 2, s->c.pict_type == AV_PICTURE_TYPE_I); /* GFID */
378 }else{
379 2544 int gob_number= mb_line / s->c.gob_index;
380
381 2544 put_bits(&s->pb, 5, gob_number); /* GN */
382 2544 put_bits(&s->pb, 2, s->c.pict_type == AV_PICTURE_TYPE_I); /* GFID */
383 2544 put_bits(&s->pb, 5, s->c.qscale); /* GQUANT */
384 }
385 2544 }
386
387 /**
388 * modify qscale so that encoding is actually possible in H.263 (limit difference to -2..2)
389 */
390 400 void ff_clean_h263_qscales(MPVEncContext *const s)
391 {
392 400 int8_t * const qscale_table = s->c.cur_pic.qscale_table;
393
394
2/2
✓ Branch 0 taken 119300 times.
✓ Branch 1 taken 400 times.
 119700 for (int i = 1; i < s->c.mb_num; i++) {
395
2/2
✓ Branch 0 taken 5845 times.
✓ Branch 1 taken 113455 times.
 119300 if (qscale_table[ s->c.mb_index2xy[i] ] - qscale_table[ s->c.mb_index2xy[i-1] ] > 2)
396 5845 qscale_table[ s->c.mb_index2xy[i] ] = qscale_table[ s->c.mb_index2xy[i-1] ] + 2;
397 }
398
2/2
✓ Branch 0 taken 119300 times.
✓ Branch 1 taken 400 times.
 119700 for(int i = s->c.mb_num - 2; i >= 0; i--) {
399
2/2
✓ Branch 0 taken 4815 times.
✓ Branch 1 taken 114485 times.
 119300 if (qscale_table[ s->c.mb_index2xy[i] ] - qscale_table[ s->c.mb_index2xy[i+1] ] > 2)
400 4815 qscale_table[ s->c.mb_index2xy[i] ] = qscale_table[ s->c.mb_index2xy[i+1] ] + 2;
401 }
402
403
1/2
✓ Branch 0 taken 400 times.
✗ Branch 1 not taken.
 400 if (s->c.codec_id != AV_CODEC_ID_H263P) {
404
2/2
✓ Branch 0 taken 119300 times.
✓ Branch 1 taken 400 times.
 119700 for (int i = 1; i < s->c.mb_num; i++) {
405 119300 int mb_xy = s->c.mb_index2xy[i];
406
407
2/2
✓ Branch 0 taken 41665 times.
✓ Branch 1 taken 77635 times.
 119300 if (qscale_table[mb_xy] != qscale_table[s->c.mb_index2xy[i - 1]] &&
408
2/2
✓ Branch 0 taken 16880 times.
✓ Branch 1 taken 24785 times.
 41665 (s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTER4V)) {
409 16880 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
410 }
411 }
412 }
413 400 }
414
415 static const int dquant_code[5]= {1,0,9,2,3};
416
417 /**
418 * Encode an 8x8 block.
419 * @param block the 8x8 block
420 * @param n block index (0-3 are luma, 4-5 are chroma)
421 */
422 2388636 static void h263_encode_block(MPVEncContext *const s, int16_t block[], int n)
423 {
424 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
425 const RLTable *rl;
426
427 2388636 rl = &ff_h263_rl_inter;
428
4/4
✓ Branch 0 taken 348792 times.
✓ Branch 1 taken 2039844 times.
✓ Branch 2 taken 266694 times.
✓ Branch 3 taken 82098 times.
 2388636 if (s->c.mb_intra && !s->c.h263_aic) {
429 /* DC coef */
430 266694 level = block[0];
431 /* 255 cannot be represented, so we clamp */
432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 266694 times.
 266694 if (level > 254) {
433 ✗ level = 254;
434 ✗ block[0] = 254;
435 }
436 /* 0 cannot be represented also */
437
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 266694 times.
 266694 else if (level < 1) {
438 ✗ level = 1;
439 ✗ block[0] = 1;
440 }
441
2/2
✓ Branch 0 taken 5826 times.
✓ Branch 1 taken 260868 times.
 266694 if (level == 128) //FIXME check rv10
442 5826 put_bits(&s->pb, 8, 0xff);
443 else
444 260868 put_bits(&s->pb, 8, level);
445 266694 i = 1;
446 } else {
447 2121942 i = 0;
448
4/4
✓ Branch 0 taken 391992 times.
✓ Branch 1 taken 1729950 times.
✓ Branch 2 taken 82098 times.
✓ Branch 3 taken 309894 times.
 2121942 if (s->c.h263_aic && s->c.mb_intra)
449 82098 rl = &ff_rl_intra_aic;
450
451
4/4
✓ Branch 0 taken 356352 times.
✓ Branch 1 taken 1765590 times.
✓ Branch 2 taken 309894 times.
✓ Branch 3 taken 46458 times.
 2121942 if(s->c.alt_inter_vlc && !s->c.mb_intra){
452 309894 int aic_vlc_bits=0;
453 309894 int inter_vlc_bits=0;
454 309894 int wrong_pos=-1;
455 int aic_code;
456
457 309894 last_index = s->c.block_last_index[n];
458 309894 last_non_zero = i - 1;
459
2/2
✓ Branch 0 taken 9817100 times.
✓ Branch 1 taken 309894 times.
 10126994 for (; i <= last_index; i++) {
460 9817100 j = s->c.intra_scantable.permutated[i];
461 9817100 level = block[j];
462
2/2
✓ Branch 0 taken 3646040 times.
✓ Branch 1 taken 6171060 times.
 9817100 if (level) {
463 3646040 run = i - last_non_zero - 1;
464 3646040 last = (i == last_index);
465
466
2/2
✓ Branch 0 taken 1800387 times.
✓ Branch 1 taken 1845653 times.
 3646040 if(level<0) level= -level;
467
468 3646040 code = get_rl_index(rl, last, run, level);
469 3646040 aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
470 3646040 inter_vlc_bits += rl->table_vlc[code][1]+1;
471 3646040 aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
472
473
2/2
✓ Branch 0 taken 238217 times.
✓ Branch 1 taken 3407823 times.
 3646040 if (code == rl->n) {
474 238217 inter_vlc_bits += 1+6+8-1;
475 }
476
2/2
✓ Branch 0 taken 160580 times.
✓ Branch 1 taken 3485460 times.
 3646040 if (aic_code == ff_rl_intra_aic.n) {
477 160580 aic_vlc_bits += 1+6+8-1;
478 160580 wrong_pos += run + 1;
479 }else
480 3485460 wrong_pos += wrong_run[aic_code];
481 3646040 last_non_zero = i;
482 }
483 }
484 309894 i = 0;
485
4/4
✓ Branch 0 taken 102063 times.
✓ Branch 1 taken 207831 times.
✓ Branch 2 taken 66459 times.
✓ Branch 3 taken 35604 times.
 309894 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
486 66459 rl = &ff_rl_intra_aic;
487 }
488 }
489
490 /* AC coefs */
491 2388636 last_index = s->c.block_last_index[n];
492 2388636 last_non_zero = i - 1;
493
2/2
✓ Branch 0 taken 37329308 times.
✓ Branch 1 taken 2388636 times.
 39717944 for (; i <= last_index; i++) {
494 37329308 j = s->c.intra_scantable.permutated[i];
495 37329308 level = block[j];
496
2/2
✓ Branch 0 taken 11712914 times.
✓ Branch 1 taken 25616394 times.
 37329308 if (level) {
497 11712914 run = i - last_non_zero - 1;
498 11712914 last = (i == last_index);
499 11712914 sign = 0;
500 11712914 slevel = level;
501
2/2
✓ Branch 0 taken 5838423 times.
✓ Branch 1 taken 5874491 times.
 11712914 if (level < 0) {
502 5838423 sign = 1;
503 5838423 level = -level;
504 }
505 11712914 code = get_rl_index(rl, last, run, level);
506 11712914 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
507
2/2
✓ Branch 0 taken 590306 times.
✓ Branch 1 taken 11122608 times.
 11712914 if (code == rl->n) {
508
2/2
✓ Branch 0 taken 402806 times.
✓ Branch 1 taken 187500 times.
 590306 if(!CONFIG_FLV_ENCODER || s->c.h263_flv <= 1){
509 402806 put_bits(&s->pb, 1, last);
510 402806 put_bits(&s->pb, 6, run);
511
512 av_assert2(slevel != 0);
513
514
2/2
✓ Branch 0 taken 400394 times.
✓ Branch 1 taken 2412 times.
 402806 if(level < 128)
515 400394 put_sbits(&s->pb, 8, slevel);
516 else{
517 2412 put_bits(&s->pb, 8, 128);
518 2412 put_sbits(&s->pb, 5, slevel);
519 2412 put_sbits(&s->pb, 6, slevel>>5);
520 }
521 }else{
522 187500 ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
523 }
524 } else {
525 11122608 put_bits(&s->pb, 1, sign);
526 }
527 11712914 last_non_zero = i;
528 }
529 }
530 2388636 }
531
532 /* Encode MV differences on H.263+ with Unrestricted MV mode */
533 103298 static void h263p_encode_umotion(PutBitContext *pb, int val)
534 {
535 103298 short sval = 0;
536 103298 short i = 0;
537 103298 short n_bits = 0;
538 short temp_val;
539 103298 int code = 0;
540 int tcode;
541
542
2/2
✓ Branch 0 taken 51255 times.
✓ Branch 1 taken 52043 times.
 103298 if ( val == 0)
543 51255 put_bits(pb, 1, 1);
544
2/2
✓ Branch 0 taken 12904 times.
✓ Branch 1 taken 39139 times.
 52043 else if (val == 1)
545 12904 put_bits(pb, 3, 0);
546
2/2
✓ Branch 0 taken 20988 times.
✓ Branch 1 taken 18151 times.
 39139 else if (val == -1)
547 20988 put_bits(pb, 3, 2);
548 else {
549
550
2/2
✓ Branch 0 taken 9429 times.
✓ Branch 1 taken 8722 times.
 18151 sval = ((val < 0) ? (short)(-val):(short)val);
551 18151 temp_val = sval;
552
553
2/2
✓ Branch 0 taken 46910 times.
✓ Branch 1 taken 18151 times.
 65061 while (temp_val != 0) {
554 46910 temp_val = temp_val >> 1;
555 46910 n_bits++;
556 }
557
558 18151 i = n_bits - 1;
559
2/2
✓ Branch 0 taken 28759 times.
✓ Branch 1 taken 18151 times.
 46910 while (i > 0) {
560 28759 tcode = (sval & (1 << (i-1))) >> (i-1);
561 28759 tcode = (tcode << 1) | 1;
562 28759 code = (code << 2) | tcode;
563 28759 i--;
564 }
565 18151 code = ((code << 1) | (val < 0)) << 1;
566 18151 put_bits(pb, (2*n_bits)+1, code);
567 }
568 103298 }
569
570 82098 static int h263_pred_dc(MPVEncContext *const s, int n, int16_t **dc_val_ptr)
571 {
572 int x, y, wrap, a, c, pred_dc;
573 int16_t *dc_val;
574
575 /* find prediction */
576
2/2
✓ Branch 0 taken 54732 times.
✓ Branch 1 taken 27366 times.
 82098 if (n < 4) {
577 54732 x = 2 * s->c.mb_x + (n & 1);
578 54732 y = 2 * s->c.mb_y + ((n & 2) >> 1);
579 54732 wrap = s->c.b8_stride;
580 54732 dc_val = s->c.dc_val[0];
581 } else {
582 27366 x = s->c.mb_x;
583 27366 y = s->c.mb_y;
584 27366 wrap = s->c.mb_stride;
585 27366 dc_val = s->c.dc_val[n - 4 + 1];
586 }
587 /* B C
588 * A X
589 */
590 82098 a = dc_val[(x - 1) + (y) * wrap];
591 82098 c = dc_val[(x) + (y - 1) * wrap];
592
593 /* No prediction outside GOB boundary */
594
4/4
✓ Branch 0 taken 48438 times.
✓ Branch 1 taken 33660 times.
✓ Branch 2 taken 40365 times.
✓ Branch 3 taken 8073 times.
 82098 if (s->c.first_slice_line && n != 3) {
595
2/2
✓ Branch 0 taken 32292 times.
✓ Branch 1 taken 8073 times.
 40365 if (n != 2) c = 1024;
596
4/4
✓ Branch 0 taken 32292 times.
✓ Branch 1 taken 8073 times.
✓ Branch 2 taken 1140 times.
✓ Branch 3 taken 31152 times.
 40365 if (n != 1 && s->c.mb_x == s->c.resync_mb_x) a = 1024;
597 }
598 /* just DC prediction */
599
4/4
✓ Branch 0 taken 76882 times.
✓ Branch 1 taken 5216 times.
✓ Branch 2 taken 47737 times.
✓ Branch 3 taken 29145 times.
 82098 if (a != 1024 && c != 1024)
600 47737 pred_dc = (a + c) >> 1;
601
2/2
✓ Branch 0 taken 29145 times.
✓ Branch 1 taken 5216 times.
 34361 else if (a != 1024)
602 29145 pred_dc = a;
603 else
604 5216 pred_dc = c;
605
606 /* we assume pred is positive */
607 82098 *dc_val_ptr = &dc_val[x + y * wrap];
608 82098 return pred_dc;
609 }
610
611 428550 static void h263_encode_mb(MPVEncContext *const s,
612 int16_t block[][64],
613 int motion_x, int motion_y)
614 {
615 int cbpc, cbpy, i, cbp, pred_x, pred_y;
616 int16_t pred_dc;
617 int16_t rec_intradc[6];
618 int16_t *dc_ptr[6];
619 428550 const int interleaved_stats = s->c.avctx->flags & AV_CODEC_FLAG_PASS1;
620
621
2/2
✓ Branch 0 taken 370418 times.
✓ Branch 1 taken 58132 times.
 428550 if (!s->c.mb_intra) {
622 /* compute cbp */
623 370418 cbp= get_p_cbp(s, block, motion_x, motion_y);
624
625
2/2
✓ Branch 0 taken 30444 times.
✓ Branch 1 taken 339974 times.
 370418 if ((cbp | motion_x | motion_y | s->dquant | (s->c.mv_type - MV_TYPE_16X16)) == 0) {
626 /* skip macroblock */
627 30444 put_bits(&s->pb, 1, 1);
628
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30444 times.
 30444 if(interleaved_stats){
629 ✗ s->misc_bits++;
630 ✗ s->last_bits++;
631 }
632
633 30444 return;
634 }
635 339974 put_bits(&s->pb, 1, 0); /* mb coded */
636
637 339974 cbpc = cbp & 3;
638 339974 cbpy = cbp >> 2;
639
4/4
✓ Branch 0 taken 51649 times.
✓ Branch 1 taken 288325 times.
✓ Branch 2 taken 13805 times.
✓ Branch 3 taken 37844 times.
 339974 if(s->c.alt_inter_vlc==0 || cbpc!=3)
640 302130 cbpy ^= 0xF;
641
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 339974 times.
 339974 if(s->dquant) cbpc+= 8;
642
1/2
✓ Branch 0 taken 339974 times.
✗ Branch 1 not taken.
 339974 if(s->c.mv_type==MV_TYPE_16X16){
643 339974 put_bits(&s->pb,
644 339974 ff_h263_inter_MCBPC_bits[cbpc],
645 339974 ff_h263_inter_MCBPC_code[cbpc]);
646
647 339974 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
648
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 339974 times.
 339974 if(s->dquant)
649 ✗ put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
650
651
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 339974 times.
 339974 if(interleaved_stats){
652 ✗ s->misc_bits+= get_bits_diff(s);
653 }
654
655 /* motion vectors: 16x16 mode */
656 339974 ff_h263_pred_motion(&s->c, 0, 0, &pred_x, &pred_y);
657
658
2/2
✓ Branch 0 taken 288325 times.
✓ Branch 1 taken 51649 times.
 339974 if (!s->c.umvplus) {
659 288325 ff_h263_encode_motion_vector(s, motion_x - pred_x,
660 motion_y - pred_y, 1);
661 }
662 else {
663 51649 h263p_encode_umotion(&s->pb, motion_x - pred_x);
664 51649 h263p_encode_umotion(&s->pb, motion_y - pred_y);
665
4/4
✓ Branch 0 taken 10131 times.
✓ Branch 1 taken 41518 times.
✓ Branch 2 taken 340 times.
✓ Branch 3 taken 9791 times.
 51649 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
666 /* To prevent Start Code emulation */
667 340 put_bits(&s->pb,1,1);
668 }
669 }else{
670 ✗ put_bits(&s->pb,
671 ✗ ff_h263_inter_MCBPC_bits[cbpc+16],
672 ✗ ff_h263_inter_MCBPC_code[cbpc+16]);
673 ✗ put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
674 ✗ if(s->dquant)
675 ✗ put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
676
677 ✗ if(interleaved_stats){
678 ✗ s->misc_bits+= get_bits_diff(s);
679 }
680
681 ✗ for(i=0; i<4; i++){
682 /* motion vectors: 8x8 mode*/
683 ✗ ff_h263_pred_motion(&s->c, i, 0, &pred_x, &pred_y);
684
685 ✗ motion_x = s->c.cur_pic.motion_val[0][s->c.block_index[i]][0];
686 ✗ motion_y = s->c.cur_pic.motion_val[0][s->c.block_index[i]][1];
687 ✗ if (!s->c.umvplus) {
688 ✗ ff_h263_encode_motion_vector(s, motion_x - pred_x,
689 motion_y - pred_y, 1);
690 }
691 else {
692 ✗ h263p_encode_umotion(&s->pb, motion_x - pred_x);
693 ✗ h263p_encode_umotion(&s->pb, motion_y - pred_y);
694 ✗ if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
695 /* To prevent Start Code emulation */
696 ✗ put_bits(&s->pb,1,1);
697 }
698 }
699 }
700
701
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 339974 times.
 339974 if(interleaved_stats){
702 ✗ s->mv_bits+= get_bits_diff(s);
703 }
704 } else {
705 av_assert2(s->c.mb_intra);
706
707 58132 cbp = 0;
708
2/2
✓ Branch 0 taken 13683 times.
✓ Branch 1 taken 44449 times.
 58132 if (s->c.h263_aic) {
709 /* Predict DC */
710
2/2
✓ Branch 0 taken 82098 times.
✓ Branch 1 taken 13683 times.
 95781 for(i=0; i<6; i++) {
711 82098 int16_t level = block[i][0];
712
2/2
✓ Branch 0 taken 54732 times.
✓ Branch 1 taken 27366 times.
 82098 int scale = i < 4 ? s->c.y_dc_scale : s->c.c_dc_scale;
713
714 82098 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
715 82098 level -= pred_dc;
716 /* Quant */
717
2/2
✓ Branch 0 taken 43407 times.
✓ Branch 1 taken 38691 times.
 82098 if (level >= 0)
718 43407 level = (level + (scale>>1))/scale;
719 else
720 38691 level = (level - (scale>>1))/scale;
721
722
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 82098 times.
 82098 if (!s->c.modified_quant) {
723 ✗ if (level < -127)
724 ✗ level = -127;
725 ✗ else if (level > 127)
726 ✗ level = 127;
727 }
728
729 82098 block[i][0] = level;
730 /* Reconstruction */
731 82098 rec_intradc[i] = scale*level + pred_dc;
732 /* Oddify */
733 82098 rec_intradc[i] |= 1;
734 //if ((rec_intradc[i] % 2) == 0)
735 // rec_intradc[i]++;
736 /* Clipping */
737
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 82098 times.
 82098 if (rec_intradc[i] < 0)
738 ✗ rec_intradc[i] = 0;
739
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 82098 times.
 82098 else if (rec_intradc[i] > 2047)
740 ✗ rec_intradc[i] = 2047;
741
742 /* Update AC/DC tables */
743 82098 *dc_ptr[i] = rec_intradc[i];
744 /* AIC can change CBP */
745
2/2
✓ Branch 0 taken 6224 times.
✓ Branch 1 taken 75874 times.
 82098 if (s->c.block_last_index[i] > 0 ||
746
3/4
✓ Branch 0 taken 6224 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4973 times.
✓ Branch 3 taken 1251 times.
 6224 (s->c.block_last_index[i] == 0 && level !=0))
747 80847 cbp |= 1 << (5 - i);
748 }
749 }else{
750
2/2
✓ Branch 0 taken 266694 times.
✓ Branch 1 taken 44449 times.
 311143 for(i=0; i<6; i++) {
751 /* compute cbp */
752
2/2
✓ Branch 0 taken 206994 times.
✓ Branch 1 taken 59700 times.
 266694 if (s->c.block_last_index[i] >= 1)
753 206994 cbp |= 1 << (5 - i);
754 }
755 }
756
757 58132 cbpc = cbp & 3;
758
2/2
✓ Branch 0 taken 45249 times.
✓ Branch 1 taken 12883 times.
 58132 if (s->c.pict_type == AV_PICTURE_TYPE_I) {
759
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45249 times.
 45249 if(s->dquant) cbpc+=4;
760 45249 put_bits(&s->pb,
761 45249 ff_h263_intra_MCBPC_bits[cbpc],
762 45249 ff_h263_intra_MCBPC_code[cbpc]);
763 } else {
764
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12883 times.
 12883 if(s->dquant) cbpc+=8;
765 12883 put_bits(&s->pb, 1, 0); /* mb coded */
766 12883 put_bits(&s->pb,
767 12883 ff_h263_inter_MCBPC_bits[cbpc + 4],
768 12883 ff_h263_inter_MCBPC_code[cbpc + 4]);
769 }
770
2/2
✓ Branch 0 taken 13683 times.
✓ Branch 1 taken 44449 times.
 58132 if (s->c.h263_aic) {
771 /* XXX: currently, we do not try to use ac prediction */
772 13683 put_bits(&s->pb, 1, 0); /* no AC prediction */
773 }
774 58132 cbpy = cbp >> 2;
775 58132 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
776
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58132 times.
 58132 if(s->dquant)
777 ✗ put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
778
779
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58132 times.
 58132 if(interleaved_stats){
780 ✗ s->misc_bits+= get_bits_diff(s);
781 }
782 }
783
784
2/2
✓ Branch 0 taken 2388636 times.
✓ Branch 1 taken 398106 times.
 2786742 for(i=0; i<6; i++) {
785 /* encode each block */
786 2388636 h263_encode_block(s, block[i], i);
787
788 /* Update INTRADC for decoding */
789
4/4
✓ Branch 0 taken 391992 times.
✓ Branch 1 taken 1996644 times.
✓ Branch 2 taken 82098 times.
✓ Branch 3 taken 309894 times.
 2388636 if (s->c.h263_aic && s->c.mb_intra)
790 82098 block[i][0] = rec_intradc[i];
791 }
792
793
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 398106 times.
 398106 if(interleaved_stats){
794 ✗ if (!s->c.mb_intra) {
795 ✗ s->p_tex_bits+= get_bits_diff(s);
796 }else{
797 ✗ s->i_tex_bits+= get_bits_diff(s);
798 ✗ s->i_count++;
799 }
800 }
801 }
802
803 1380408 void ff_h263_update_mb(MPVEncContext *const s)
804 {
805 1380408 const int mb_xy = s->c.mb_y * s->c.mb_stride + s->c.mb_x;
806
807
2/2
✓ Branch 0 taken 702558 times.
✓ Branch 1 taken 677850 times.
 1380408 if (s->c.cur_pic.mbskip_table)
808 702558 s->c.cur_pic.mbskip_table[mb_xy] = s->c.mb_skipped;
809
810
2/2
✓ Branch 0 taken 82021 times.
✓ Branch 1 taken 1298387 times.
 1380408 if (s->c.mv_type == MV_TYPE_8X8)
811 82021 s->c.cur_pic.mb_type[mb_xy] = MB_TYPE_FORWARD_MV | MB_TYPE_8x8;
812
2/2
✓ Branch 0 taken 221358 times.
✓ Branch 1 taken 1077029 times.
 1298387 else if(s->c.mb_intra)
813 221358 s->c.cur_pic.mb_type[mb_xy] = MB_TYPE_INTRA;
814 else
815 1077029 s->c.cur_pic.mb_type[mb_xy] = MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
816
817 1380408 ff_h263_update_motion_val(&s->c);
818 1380408 }
819
820 103 av_cold void ff_h263_encode_init(MPVMainEncContext *const m)
821 {
822 103 MPVEncContext *const s = &m->s;
823
824 103 s->me.mv_penalty = ff_h263_get_mv_penalty(); // FIXME exact table for MSMPEG4 & H.263+
825
826 103 ff_h263dsp_init(&s->c.h263dsp);
827
828
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 40 times.
 103 if (s->c.codec_id == AV_CODEC_ID_MPEG4)
829 63 return;
830
831 40 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
832 40 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
833
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 34 times.
 40 if (s->c.h263_aic) {
834 6 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
835 6 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
836
837 6 s->c.y_dc_scale_table =
838 6 s->c.c_dc_scale_table = ff_aic_dc_scale_table;
839 }
840 40 s->ac_esc_length= 7+1+6+8;
841
842
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 34 times.
 40 if (s->c.modified_quant)
843 6 s->c.chroma_qscale_table = ff_h263_chroma_qscale_table;
844
845 // Only used for H.263 and H.263+
846
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 40 s->c.gob_index = H263_GOB_HEIGHT(s->c.height);
847
848 // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
849
3/3
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 30 times.
 40 switch(s->c.codec_id){
850 3 case AV_CODEC_ID_H263P:
851
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (s->c.umvplus)
852 3 m->fcode_tab = umv_fcode_tab + MAX_MV;
853
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (s->c.modified_quant) {
854 3 s->min_qcoeff= -2047;
855 3 s->max_qcoeff= 2047;
856 }else{
857 ✗ s->min_qcoeff= -127;
858 ✗ s->max_qcoeff= 127;
859 }
860 3 break;
861 // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
862 #if CONFIG_FLV_ENCODER
863 7 case AV_CODEC_ID_FLV1:
864 7 m->encode_picture_header = ff_flv_encode_picture_header;
865
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 if (s->c.h263_flv > 1) {
866 7 s->min_qcoeff= -1023;
867 7 s->max_qcoeff= 1023;
868 } else {
869 ✗ s->min_qcoeff= -127;
870 ✗ s->max_qcoeff= 127;
871 }
872 7 break;
873 #endif
874 30 default: //nothing needed - default table already set in mpegvideo.c
875 30 s->min_qcoeff= -127;
876 30 s->max_qcoeff= 127;
877 }
878 // H.263, H.263+; will be overwritten for MSMPEG-4 later
879
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 18 times.
 40 if (!m->encode_picture_header)
880 22 m->encode_picture_header = h263_encode_picture_header;
881
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 4 times.
 40 if (!s->encode_mb)
882 36 s->encode_mb = h263_encode_mb;
883 }
884
885 150 void ff_h263_encode_mba(MPVEncContext *const s)
886 {
887 int i, mb_pos;
888
889
1/2
✓ Branch 0 taken 450 times.
✗ Branch 1 not taken.
 450 for(i=0; i<6; i++){
890
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 300 times.
 450 if(s->c.mb_num-1 <= ff_mba_max[i]) break;
891 }
892 150 mb_pos= s->c.mb_x + s->c.mb_width*s->c.mb_y;
893 150 put_bits(&s->pb, ff_mba_length[i], mb_pos);
894 150 }
895
896 #define OFFSET(x) offsetof(MpegEncContext, x)
897 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
898 static const AVOption h263_options[] = {
899 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
900 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", FF_MPV_OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
901 FF_MPV_COMMON_OPTS
902 FF_MPV_COMMON_MOTION_EST_OPTS
903 { NULL },
904 };
905
906 static const AVClass h263_class = {
907 .class_name = "H.263 encoder",
908 .item_name = av_default_item_name,
909 .option = h263_options,
910 .version = LIBAVUTIL_VERSION_INT,
911 };
912
913 const FFCodec ff_h263_encoder = {
914 .p.name = "h263",
915 CODEC_LONG_NAME("H.263 / H.263-1996"),
916 .p.type = AVMEDIA_TYPE_VIDEO,
917 .p.id = AV_CODEC_ID_H263,
918 CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
919 .color_ranges = AVCOL_RANGE_MPEG,
920 .p.priv_class = &h263_class,
921 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
922 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
923 .priv_data_size = sizeof(MPVMainEncContext),
924 .init = ff_mpv_encode_init,
925 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
926 .close = ff_mpv_encode_end,
927 };
928
929 static const AVOption h263p_options[] = {
930 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
931 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
932 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
933 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
934 FF_MPV_COMMON_OPTS
935 FF_MPV_COMMON_MOTION_EST_OPTS
936 { NULL },
937 };
938 static const AVClass h263p_class = {
939 .class_name = "H.263p encoder",
940 .item_name = av_default_item_name,
941 .option = h263p_options,
942 .version = LIBAVUTIL_VERSION_INT,
943 };
944
945 const FFCodec ff_h263p_encoder = {
946 .p.name = "h263p",
947 CODEC_LONG_NAME("H.263+ / H.263-1998 / H.263 version 2"),
948 .p.type = AVMEDIA_TYPE_VIDEO,
949 .p.id = AV_CODEC_ID_H263P,
950 CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
951 .color_ranges = AVCOL_RANGE_MPEG,
952 .p.priv_class = &h263p_class,
953 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS |
954 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
955 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
956 .priv_data_size = sizeof(MPVMainEncContext),
957 .init = ff_mpv_encode_init,
958 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
959 .close = ff_mpv_encode_end,
960 };
961 #endif
962