FFmpeg coverage

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