FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/ituh263enc.c
Date: 2026-01-23 19:11:46
Exec Total Coverage
Lines: 413 475 86.9%
Functions: 18 18 100.0%
Branches: 197 255 77.3%
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 "mpegvideodata.h"
42 #include "mpegvideoenc.h"
43 #include "h263.h"
44 #include "h263enc.h"
45 #include "h263data.h"
46 #include "h263dsp.h"
47 #include "mathops.h"
48 #include "mpegutils.h"
49 #include "internal.h"
50 #include "put_bits.h"
51
52 /**
53 * Table of number of bits a motion vector component needs.
54 */
55 static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];
56
57 118 static av_cold void init_mv_penalty(void)
58 {
59
2/2
✓ Branch 0 taken 826 times.
✓ Branch 1 taken 118 times.
 944 for (int f_code = 1; f_code <= MAX_FCODE; f_code++) {
60
2/2
✓ Branch 0 taken 13534010 times.
✓ Branch 1 taken 826 times.
 13534836 for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
61 int len;
62
63
2/2
✓ Branch 0 taken 826 times.
✓ Branch 1 taken 13533184 times.
 13534010 if (mv == 0) len = 1; // ff_mvtab[0][1]
64 else {
65 int val, bit_size, code;
66
67 13533184 bit_size = f_code - 1;
68
69 13533184 val = mv;
70
2/2
✓ Branch 0 taken 6766592 times.
✓ Branch 1 taken 6766592 times.
 13533184 if (val < 0)
71 6766592 val = -val;
72 13533184 val--;
73 13533184 code = (val >> bit_size) + 1;
74
2/2
✓ Branch 0 taken 959104 times.
✓ Branch 1 taken 12574080 times.
 13533184 if (code < 33) {
75 959104 len = ff_mvtab[code][1] + 1 + bit_size;
76 } else {
77 12574080 len = 12 /* ff_mvtab[32][1] */ + av_log2(code>>5) + 2 + bit_size;
78 }
79 }
80
81 13534010 mv_penalty[f_code][mv + MAX_DMV] = len;
82 }
83 }
84 118 }
85
86 #if CONFIG_H263_ENCODER
87 /**
88 * Minimal fcode that a motion vector component would need in umv.
89 * All entries in this table are 1.
90 */
91 static uint8_t umv_fcode_tab[MAX_MV*2+1];
92
93 //unified encoding tables for run length encoding of coefficients
94 //unified in the sense that the specification specifies the encoding in several steps.
95 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
96 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
97 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
98 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
99 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
100
101 236 static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
102 {
103 236 const uint16_t (*table_vlc)[2] = rl->table_vlc;
104 236 const uint8_t *table_run = rl->table_run;
105 236 const uint8_t *table_level = rl->table_level;
106
107 av_assert0(MAX_LEVEL >= 64);
108 av_assert0(MAX_RUN >= 63);
109
110 // Note: The LUT only covers level values for which the escape value
111 // is eight bits (not 8 + 5 + 6)
112 236 memset(len_tab, H263_ESCAPE_CODE_LENGTH + 1 + 6 + 8,
113 sizeof(uni_h263_intra_aic_rl_len));
114
115 236 len_tab += 64; // simplifies addressing
116
2/2
✓ Branch 0 taken 24072 times.
✓ Branch 1 taken 236 times.
 24308 for (int i = 0; i < H263_RL_NB_ELEMS; ++i) {
117 24072 int run = table_run[i];
118 24072 int level = table_level[i];
119 24072 int last = i >= H263_RL_NON_LAST_CODES;
120 24072 int len = table_vlc[i][1];
121
122 24072 len_tab[UNI_MPEG4_ENC_INDEX(last, run, level)] =
123 24072 len_tab[UNI_MPEG4_ENC_INDEX(last, run, -level)] = len + 1 /* sign */;
124 }
125
2/2
✓ Branch 0 taken 15104 times.
✓ Branch 1 taken 236 times.
 15340 for (int run = 0; run < MAX_RUN; ++run) {
126 15104 len_tab[UNI_MPEG4_ENC_INDEX(0, run, 0)] =
127 15104 len_tab[UNI_MPEG4_ENC_INDEX(1, run, 0)] = 0; // is this necessary?
128 }
129 236 }
130 #endif
131
132 118 static av_cold void h263_encode_init_static(void)
133 {
134 #if CONFIG_H263_ENCODER
135 static uint8_t rl_intra_table[2][2 * MAX_RUN + MAX_LEVEL + 3];
136 118 ff_rl_init(&ff_rl_intra_aic, rl_intra_table);
137 118 ff_h263_init_rl_inter();
138
139 118 init_uni_h263_rl_tab(&ff_rl_intra_aic, uni_h263_intra_aic_rl_len);
140 118 init_uni_h263_rl_tab(&ff_h263_rl_inter, uni_h263_inter_rl_len);
141
142 118 memset(umv_fcode_tab, 1, sizeof(umv_fcode_tab));
143 #endif
144
145 118 init_mv_penalty();
146 118 }
147
148 118 av_cold const uint8_t (*ff_h263_get_mv_penalty(void))[MAX_DMV*2+1]
149 {
150 static AVOnce init_static_once = AV_ONCE_INIT;
151
152 118 ff_thread_once(&init_static_once, h263_encode_init_static);
153
154 118 return mv_penalty;
155 }
156
157 5426130 void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
158 {
159
2/2
✓ Branch 0 taken 2264719 times.
✓ Branch 1 taken 3161411 times.
 5426130 if (val == 0) {
160 /* zero vector -- corresponds to ff_mvtab[0] */
161 2264719 put_bits(pb, 1, 1);
162 } else {
163 int sign, code, bits;
164 3161411 int bit_size = f_code - 1;
165 3161411 int range = 1 << bit_size;
166 /* modulo encoding */
167 3161411 val = sign_extend(val, 6 + bit_size);
168 3161411 sign = val>>31;
169 3161411 val= (val^sign)-sign;
170 3161411 sign&=1;
171
172 3161411 val--;
173 3161411 code = (val >> bit_size) + 1;
174 3161411 bits = val & (range - 1);
175
176 3161411 put_bits(pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
177
2/2
✓ Branch 0 taken 367240 times.
✓ Branch 1 taken 2794171 times.
 3161411 if (bit_size > 0) {
178 367240 put_bits(pb, bit_size, bits);
179 }
180 }
181 5426130 }
182
183 #if CONFIG_H263_ENCODER // Snow and SVQ1 need the above
184 static const uint8_t wrong_run[102] = {
185 1, 2, 3, 5, 4, 10, 9, 8,
186 11, 15, 17, 16, 23, 22, 21, 20,
187 19, 18, 25, 24, 27, 26, 11, 7,
188 6, 1, 2, 13, 2, 2, 2, 2,
189 6, 12, 3, 9, 1, 3, 4, 3,
190 7, 4, 1, 1, 5, 5, 14, 6,
191 1, 7, 1, 8, 1, 1, 1, 1,
192 10, 1, 1, 5, 9, 17, 25, 24,
193 29, 33, 32, 41, 2, 23, 28, 31,
194 3, 22, 30, 4, 27, 40, 8, 26,
195 6, 39, 7, 38, 16, 37, 15, 10,
196 11, 12, 13, 14, 1, 21, 20, 18,
197 19, 2, 1, 34, 35, 36
198 };
199
200 /**
201 * Return the 4 bit value that specifies the given aspect ratio.
202 * This may be one of the standard aspect ratios or it specifies
203 * that the aspect will be stored explicitly later.
204 */
205 222 av_const int ff_h263_aspect_to_info(AVRational aspect){
206 int i;
207
208
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};
209
210
1/2
✓ Branch 0 taken 222 times.
✗ Branch 1 not taken.
 222 for(i=1; i<6; i++){
211
1/2
✓ Branch 1 taken 222 times.
✗ Branch 2 not taken.
 222 if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
212 222 return i;
213 }
214 }
215
216 ✗ return FF_ASPECT_EXTENDED;
217 }
218
219 450 static int h263_encode_picture_header(MPVMainEncContext *const m)
220 {
221 450 MPVEncContext *const s = &m->s;
222 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
223 450 int best_clock_code=1;
224 450 int best_divisor=60;
225 450 int best_error= INT_MAX;
226 int custom_pcf;
227
228 450 put_bits_assume_flushed(&s->pb);
229
230
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 300 times.
 450 if (s->c.codec_id == AV_CODEC_ID_H263P) {
231
2/2
✓ Branch 0 taken 300 times.
✓ Branch 1 taken 150 times.
 450 for(i=0; i<2; i++){
232 int div, error;
233 300 div= (s->c.avctx->time_base.num*1800000LL + 500LL*s->c.avctx->time_base.den) / ((1000LL+i)*s->c.avctx->time_base.den);
234 300 div= av_clip(div, 1, 127);
235
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);
236
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 150 times.
 300 if(error < best_error){
237 150 best_error= error;
238 150 best_divisor= div;
239 150 best_clock_code= i;
240 }
241 }
242 }
243
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;
244 450 coded_frame_rate= 1800000;
245 450 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
246
247 450 put_bits(&s->pb, 22, 0x20); /* PSC */
248 450 temp_ref = s->picture_number * (int64_t)coded_frame_rate * s->c.avctx->time_base.num / //FIXME use timestamp
249 450 (coded_frame_rate_base * (int64_t)s->c.avctx->time_base.den);
250 450 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
251
252 450 put_bits(&s->pb, 1, 1); /* marker */
253 450 put_bits(&s->pb, 1, 0); /* H.263 id */
254 450 put_bits(&s->pb, 1, 0); /* split screen off */
255 450 put_bits(&s->pb, 1, 0); /* camera off */
256 450 put_bits(&s->pb, 1, 0); /* freeze picture release off */
257
258 450 format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->c.width, s->c.height);
259
2/2
✓ Branch 0 taken 300 times.
✓ Branch 1 taken 150 times.
 450 if (s->c.codec_id != AV_CODEC_ID_H263P) {
260 /* H.263v1 */
261 300 put_bits(&s->pb, 3, format);
262 300 put_bits(&s->pb, 1, (s->c.pict_type == AV_PICTURE_TYPE_P));
263 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
264 of H.263v1 UMV implies to check the predicted MV after
265 calculation of the current MB to see if we're on the limits */
266 300 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
267 300 put_bits(&s->pb, 1, 0); /* SAC: off */
268 300 put_bits(&s->pb, 1, s->c.obmc); /* Advanced Prediction */
269 300 put_bits(&s->pb, 1, 0); /* only I/P-frames, no PB-frame */
270 300 put_bits(&s->pb, 5, s->c.qscale);
271 300 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
272 } else {
273 150 int ufep=1;
274 /* H.263v2 */
275 /* H.263 Plus PTYPE */
276
277 150 put_bits(&s->pb, 3, 7);
278 150 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
279
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 150 times.
 150 if (format == 8)
280 ✗ put_bits(&s->pb,3,6); /* Custom Source Format */
281 else
282 150 put_bits(&s->pb, 3, format);
283
284 150 put_bits(&s->pb,1, custom_pcf);
285 150 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
286 150 put_bits(&s->pb,1,0); /* SAC: off */
287 150 put_bits(&s->pb,1,s->c.obmc); /* Advanced Prediction Mode */
288 150 put_bits(&s->pb,1,s->c.h263_aic); /* Advanced Intra Coding */
289 150 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
290 150 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
291 150 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
292 150 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
293 150 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
294 150 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
295 150 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
296 150 put_bits(&s->pb,3,0); /* Reserved */
297
298 150 put_bits(&s->pb, 3, s->c.pict_type == AV_PICTURE_TYPE_P);
299
300 150 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
301 150 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
302 150 put_bits(&s->pb,1,s->c.no_rounding); /* Rounding Type */
303 150 put_bits(&s->pb,2,0); /* Reserved */
304 150 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
305
306 /* This should be here if PLUSPTYPE */
307 150 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
308
309
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 150 times.
 150 if (format == 8) {
310 /* Custom Picture Format (CPFMT) */
311 ✗ unsigned aspect_ratio_info = ff_h263_aspect_to_info(s->c.avctx->sample_aspect_ratio);
312
313 ✗ put_bits(&s->pb,4, aspect_ratio_info);
314 ✗ put_bits(&s->pb,9,(s->c.width >> 2) - 1);
315 ✗ put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
316 ✗ put_bits(&s->pb,9,(s->c.height >> 2));
317 ✗ if (aspect_ratio_info == FF_ASPECT_EXTENDED){
318 ✗ put_bits(&s->pb, 8, s->c.avctx->sample_aspect_ratio.num);
319 ✗ put_bits(&s->pb, 8, s->c.avctx->sample_aspect_ratio.den);
320 }
321 }
322
1/2
✓ Branch 0 taken 150 times.
✗ Branch 1 not taken.
 150 if (custom_pcf) {
323
1/2
✓ Branch 0 taken 150 times.
✗ Branch 1 not taken.
 150 if(ufep){
324 150 put_bits(&s->pb, 1, best_clock_code);
325 150 put_bits(&s->pb, 7, best_divisor);
326 }
327 150 put_sbits(&s->pb, 2, temp_ref>>8);
328 }
329
330 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
331
1/2
✓ Branch 0 taken 150 times.
✗ Branch 1 not taken.
 150 if (s->umvplus)
332 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
333 //FIXME check actual requested range
334 150 put_bits(&s->pb,2,1); /* unlimited */
335
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 150 times.
 150 if (s->h263_slice_structured)
336 ✗ put_bits(&s->pb,2,0); /* no weird submodes */
337
338 150 put_bits(&s->pb, 5, s->c.qscale);
339 }
340
341 450 put_bits(&s->pb, 1, 0); /* no PEI */
342
343
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 450 times.
 450 if (s->h263_slice_structured) {
344 ✗ put_bits(&s->pb, 1, 1);
345
346 av_assert1(s->c.mb_x == 0 && s->c.mb_y == 0);
347 ✗ ff_h263_encode_mba(s);
348
349 ✗ put_bits(&s->pb, 1, 1);
350 }
351
352 450 return 0;
353 }
354
355 5867 void ff_h263_mpeg4_reset_dc(MPVEncContext *s)
356 {
357 5867 int16_t *dc = s->c.dc_val;
358
359 // The "- 1" is for the top-left entry
360 5867 const int l_xy = s->c.block_index[2];
361
2/2
✓ Branch 0 taken 263498 times.
✓ Branch 1 taken 5867 times.
 269365 for (int i = l_xy - 2 * s->c.b8_stride - 1; i < l_xy; i += 2)
362 263498 AV_WN32A(dc + i, 1024 << 16 | 1024);
363
364 5867 const int u_xy = s->c.block_index[4];
365 5867 const int v_xy = s->c.block_index[5];
366 5867 int16_t *dc2 = dc + v_xy - u_xy;
367
2/2
✓ Branch 0 taken 137616 times.
✓ Branch 1 taken 5867 times.
 143483 for (int i = u_xy - s->c.mb_stride - 1; i < u_xy; ++i)
368 137616 dc[i] = dc2[i] = 1024;
369 5867 }
370
371 /**
372 * Encode a group of blocks header.
373 */
374 2544 void ff_h263_encode_gob_header(MPVEncContext *const s, int mb_line)
375 {
376 2544 put_bits(&s->pb, 17, 1); /* GBSC */
377
378
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2544 times.
 2544 if (s->h263_slice_structured) {
379 ✗ put_bits(&s->pb, 1, 1);
380
381 ✗ ff_h263_encode_mba(s);
382
383 ✗ if(s->c.mb_num > 1583)
384 ✗ put_bits(&s->pb, 1, 1);
385 ✗ put_bits(&s->pb, 5, s->c.qscale); /* GQUANT */
386 ✗ put_bits(&s->pb, 1, 1);
387 ✗ put_bits(&s->pb, 2, s->c.pict_type == AV_PICTURE_TYPE_I); /* GFID */
388 }else{
389 2544 int gob_number = mb_line / s->gob_index;
390
391 2544 put_bits(&s->pb, 5, gob_number); /* GN */
392 2544 put_bits(&s->pb, 2, s->c.pict_type == AV_PICTURE_TYPE_I); /* GFID */
393 2544 put_bits(&s->pb, 5, s->c.qscale); /* GQUANT */
394 }
395 2544 }
396
397 /**
398 * modify qscale so that encoding is actually possible in H.263 (limit difference to -2..2)
399 */
400 400 void ff_clean_h263_qscales(MPVEncContext *const s)
401 {
402 400 int8_t * const qscale_table = s->c.cur_pic.qscale_table;
403
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
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)
406 5845 qscale_table[ s->c.mb_index2xy[i] ] = qscale_table[ s->c.mb_index2xy[i-1] ] + 2;
407 }
408
2/2
✓ Branch 0 taken 119300 times.
✓ Branch 1 taken 400 times.
 119700 for(int i = s->c.mb_num - 2; i >= 0; i--) {
409
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)
410 4815 qscale_table[ s->c.mb_index2xy[i] ] = qscale_table[ s->c.mb_index2xy[i+1] ] + 2;
411 }
412
413
1/2
✓ Branch 0 taken 400 times.
✗ Branch 1 not taken.
 400 if (s->c.codec_id != AV_CODEC_ID_H263P) {
414
2/2
✓ Branch 0 taken 119300 times.
✓ Branch 1 taken 400 times.
 119700 for (int i = 1; i < s->c.mb_num; i++) {
415 119300 int mb_xy = s->c.mb_index2xy[i];
416
417
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]] &&
418
2/2
✓ Branch 0 taken 16880 times.
✓ Branch 1 taken 24785 times.
 41665 (s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTER4V)) {
419 16880 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
420 }
421 }
422 }
423 400 }
424
425 static const int dquant_code[5]= {1,0,9,2,3};
426
427 187500 static void flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level,
428 int run, int last)
429 {
430 unsigned code;
431 int bits;
432
2/2
✓ Branch 0 taken 175592 times.
✓ Branch 1 taken 11908 times.
 187500 if (level < 64) { // 7-bit level
433 175592 bits = 1 + 1 + 6 + 7;
434 175592 code = (0 << (1 + 6 + 7)) |
435 175592 (last << (6 + 7)) |
436 175592 (run << 7) |
437 175592 (slevel & 0x7f);
438 } else {
439 /* 11-bit level */
440 11908 bits = 1 + 1 + 6 + 11;
441 11908 code = (1 << (1 + 6 + 11)) |
442 11908 (last << (6 + 11)) |
443 11908 (run << 11) |
444 11908 (slevel & 0x7ff);
445 }
446 187500 put_bits(pb, bits, code);
447 187500 }
448
449 /**
450 * Encode an 8x8 block.
451 * @param block the 8x8 block
452 * @param n block index (0-3 are luma, 4-5 are chroma)
453 */
454 2388636 static void h263_encode_block(MPVEncContext *const s, int16_t block[], int n)
455 {
456 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
457 const RLTable *rl;
458
459 2388636 rl = &ff_h263_rl_inter;
460
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) {
461 /* DC coef */
462 266694 level = block[0];
463 /* 255 cannot be represented, so we clamp */
464
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 266694 times.
 266694 if (level > 254) {
465 ✗ level = 254;
466 ✗ block[0] = 254;
467 }
468 /* 0 cannot be represented also */
469
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 266694 times.
 266694 else if (level < 1) {
470 ✗ level = 1;
471 ✗ block[0] = 1;
472 }
473
2/2
✓ Branch 0 taken 5826 times.
✓ Branch 1 taken 260868 times.
 266694 if (level == 128) //FIXME check rv10
474 5826 put_bits(&s->pb, 8, 0xff);
475 else
476 260868 put_bits(&s->pb, 8, level);
477 266694 i = 1;
478 } else {
479 2121942 i = 0;
480
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)
481 82098 rl = &ff_rl_intra_aic;
482
483
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->alt_inter_vlc && !s->c.mb_intra) {
484 309894 int aic_vlc_bits=0;
485 309894 int inter_vlc_bits=0;
486 309894 int wrong_pos=-1;
487 int aic_code;
488
489 309894 last_index = s->c.block_last_index[n];
490 309894 last_non_zero = i - 1;
491
2/2
✓ Branch 0 taken 9817100 times.
✓ Branch 1 taken 309894 times.
 10126994 for (; i <= last_index; i++) {
492 9817100 j = s->c.intra_scantable.permutated[i];
493 9817100 level = block[j];
494
2/2
✓ Branch 0 taken 3646040 times.
✓ Branch 1 taken 6171060 times.
 9817100 if (level) {
495 3646040 run = i - last_non_zero - 1;
496 3646040 last = (i == last_index);
497
498
2/2
✓ Branch 0 taken 1800387 times.
✓ Branch 1 taken 1845653 times.
 3646040 if(level<0) level= -level;
499
500 3646040 code = get_rl_index(rl, last, run, level);
501 3646040 aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
502 3646040 inter_vlc_bits += rl->table_vlc[code][1]+1;
503 3646040 aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
504
505
2/2
✓ Branch 0 taken 238217 times.
✓ Branch 1 taken 3407823 times.
 3646040 if (code == rl->n) {
506 238217 inter_vlc_bits += 1+6+8-1;
507 }
508
2/2
✓ Branch 0 taken 160580 times.
✓ Branch 1 taken 3485460 times.
 3646040 if (aic_code == ff_rl_intra_aic.n) {
509 160580 aic_vlc_bits += 1+6+8-1;
510 160580 wrong_pos += run + 1;
511 }else
512 3485460 wrong_pos += wrong_run[aic_code];
513 3646040 last_non_zero = i;
514 }
515 }
516 309894 i = 0;
517
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)
518 66459 rl = &ff_rl_intra_aic;
519 }
520 }
521
522 /* AC coefs */
523 2388636 last_index = s->c.block_last_index[n];
524 2388636 last_non_zero = i - 1;
525
2/2
✓ Branch 0 taken 37329308 times.
✓ Branch 1 taken 2388636 times.
 39717944 for (; i <= last_index; i++) {
526 37329308 j = s->c.intra_scantable.permutated[i];
527 37329308 level = block[j];
528
2/2
✓ Branch 0 taken 11712914 times.
✓ Branch 1 taken 25616394 times.
 37329308 if (level) {
529 11712914 run = i - last_non_zero - 1;
530 11712914 last = (i == last_index);
531 11712914 sign = 0;
532 11712914 slevel = level;
533
2/2
✓ Branch 0 taken 5838423 times.
✓ Branch 1 taken 5874491 times.
 11712914 if (level < 0) {
534 5838423 sign = 1;
535 5838423 level = -level;
536 }
537 11712914 code = get_rl_index(rl, last, run, level);
538 11712914 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
539
2/2
✓ Branch 0 taken 590306 times.
✓ Branch 1 taken 11122608 times.
 11712914 if (code == rl->n) {
540
2/2
✓ Branch 0 taken 402806 times.
✓ Branch 1 taken 187500 times.
 590306 if (!CONFIG_FLV_ENCODER || s->c.codec_id != AV_CODEC_ID_FLV1) {
541 402806 put_bits(&s->pb, 1, last);
542 402806 put_bits(&s->pb, 6, run);
543
544 av_assert2(slevel != 0);
545
546
2/2
✓ Branch 0 taken 400394 times.
✓ Branch 1 taken 2412 times.
 402806 if (level < 128) {
547 400394 put_sbits(&s->pb, 8, slevel);
548 } else {
549 2412 put_bits(&s->pb, 8, 128);
550 2412 put_sbits(&s->pb, 5, slevel);
551 2412 put_sbits(&s->pb, 6, slevel>>5);
552 }
553 } else {
554 187500 flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
555 }
556 } else {
557 11122608 put_bits(&s->pb, 1, sign);
558 }
559 11712914 last_non_zero = i;
560 }
561 }
562 2388636 }
563
564 /* Encode MV differences on H.263+ with Unrestricted MV mode */
565 103298 static void h263p_encode_umotion(PutBitContext *pb, int val)
566 {
567
2/2
✓ Branch 0 taken 51255 times.
✓ Branch 1 taken 52043 times.
 103298 if ( val == 0)
568 51255 put_bits(pb, 1, 1);
569 else {
570 52043 unsigned code = (val < 0) << 1;
571 52043 unsigned aval = val < 0 ? -val : val;
572 52043 unsigned n_bits = 2;
573
574
2/2
✓ Branch 0 taken 28759 times.
✓ Branch 1 taken 52043 times.
 80802 while (aval != 1) { // The leading digit is implicitly coded via length
575 28759 unsigned tmp = (aval & 1) << 1 | 1;
576 28759 aval >>= 1;
577 28759 code |= tmp << n_bits;
578 28759 n_bits += 2;
579 }
580 52043 put_bits(pb, n_bits + 1, code);
581 }
582 103298 }
583
584 82098 static int h263_pred_dc(MPVEncContext *const s, int n, int16_t **dc_val_ptr)
585 {
586 82098 const int wrap = s->c.block_wrap[n];
587 82098 const int xy = s->c.block_index[n];
588 82098 int16_t *const dc_val = s->c.dc_val + xy;
589 int pred_dc;
590
591 /* find prediction */
592 /* B C
593 * A X
594 */
595 82098 int a = dc_val[-1];
596 82098 int c = dc_val[-wrap];
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;
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 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->alt_inter_vlc || 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->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->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 int16_t *dc_ptr;
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);
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->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 = 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 103 ff_permute_scantable(s->permutated_intra_h_scantable, ff_alternate_horizontal_scan,
829 103 s->c.idsp.idct_permutation);
830 103 ff_permute_scantable(s->permutated_intra_v_scantable, ff_alternate_vertical_scan,
831 103 s->c.idsp.idct_permutation);
832
833
2/2
✓ Branch 0 taken 63 times.
✓ Branch 1 taken 40 times.
 103 if (s->c.codec_id == AV_CODEC_ID_MPEG4)
834 63 return;
835
836 40 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
837 40 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
838
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 34 times.
 40 if (s->c.h263_aic) {
839 6 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
840 6 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
841
842 6 s->c.y_dc_scale_table =
843 6 s->c.c_dc_scale_table = ff_aic_dc_scale_table;
844 }
845 40 s->ac_esc_length= 7+1+6+8;
846
847
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 34 times.
 40 if (s->modified_quant)
848 6 s->c.chroma_qscale_table = ff_h263_chroma_qscale_table;
849
850 // Only used for H.263 and H.263+
851
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 40 s->gob_index = H263_GOB_HEIGHT(s->c.height);
852
853 // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
854
3/3
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 30 times.
 40 switch(s->c.codec_id){
855 3 case AV_CODEC_ID_H263P:
856
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (s->umvplus)
857 3 m->fcode_tab = umv_fcode_tab + MAX_MV;
858
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (s->modified_quant) {
859 3 s->min_qcoeff= -2047;
860 3 s->max_qcoeff= 2047;
861 }else{
862 ✗ s->min_qcoeff= -127;
863 ✗ s->max_qcoeff= 127;
864 }
865 3 break;
866 // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
867 #if CONFIG_FLV_ENCODER
868 7 case AV_CODEC_ID_FLV1:
869 7 m->encode_picture_header = ff_flv_encode_picture_header;
870 /* format = 1; 11-bit codes */
871 7 s->min_qcoeff = -1023;
872 7 s->max_qcoeff = 1023;
873 7 break;
874 #endif
875 30 default: //nothing needed - default table already set in mpegvideo.c
876 30 s->min_qcoeff= -127;
877 30 s->max_qcoeff= 127;
878 }
879 // H.263, H.263+; will be overwritten for MSMPEG-4 later
880
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 18 times.
 40 if (!m->encode_picture_header)
881 22 m->encode_picture_header = h263_encode_picture_header;
882
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 4 times.
 40 if (!s->encode_mb)
883 36 s->encode_mb = h263_encode_mb;
884 }
885
886 150 void ff_h263_encode_mba(MPVEncContext *const s)
887 {
888 int i, mb_pos;
889
890
1/2
✓ Branch 0 taken 450 times.
✗ Branch 1 not taken.
 450 for(i=0; i<6; i++){
891
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 300 times.
 450 if(s->c.mb_num-1 <= ff_mba_max[i]) break;
892 }
893 150 mb_pos= s->c.mb_x + s->c.mb_width*s->c.mb_y;
894 150 put_bits(&s->pb, ff_mba_length[i], mb_pos);
895 150 }
896
897 #define OFFSET(x) offsetof(MpegEncContext, x)
898 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
899 static const AVOption h263_options[] = {
900 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
901 { "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 },
902 FF_MPV_COMMON_OPTS
903 FF_MPV_COMMON_MOTION_EST_OPTS
904 { NULL },
905 };
906
907 static const AVClass h263_class = {
908 .class_name = "H.263 encoder",
909 .item_name = av_default_item_name,
910 .option = h263_options,
911 .version = LIBAVUTIL_VERSION_INT,
912 };
913
914 const FFCodec ff_h263_encoder = {
915 .p.name = "h263",
916 CODEC_LONG_NAME("H.263 / H.263-1996"),
917 .p.type = AVMEDIA_TYPE_VIDEO,
918 .p.id = AV_CODEC_ID_H263,
919 CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
920 .color_ranges = AVCOL_RANGE_MPEG,
921 .p.priv_class = &h263_class,
922 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
923 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
924 .priv_data_size = sizeof(MPVMainEncContext),
925 .init = ff_mpv_encode_init,
926 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
927 .close = ff_mpv_encode_end,
928 };
929
930 static const AVOption h263p_options[] = {
931 { "umv", "Use unlimited motion vectors.", FF_MPV_OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
932 { "aiv", "Use alternative inter VLC.", FF_MPV_OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
933 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
934 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", FF_MPV_OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
935 FF_MPV_COMMON_OPTS
936 FF_MPV_COMMON_MOTION_EST_OPTS
937 { NULL },
938 };
939 static const AVClass h263p_class = {
940 .class_name = "H.263p encoder",
941 .item_name = av_default_item_name,
942 .option = h263p_options,
943 .version = LIBAVUTIL_VERSION_INT,
944 };
945
946 const FFCodec ff_h263p_encoder = {
947 .p.name = "h263p",
948 CODEC_LONG_NAME("H.263+ / H.263-1998 / H.263 version 2"),
949 .p.type = AVMEDIA_TYPE_VIDEO,
950 .p.id = AV_CODEC_ID_H263P,
951 CODEC_PIXFMTS(AV_PIX_FMT_YUV420P),
952 .color_ranges = AVCOL_RANGE_MPEG,
953 .p.priv_class = &h263p_class,
954 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS |
955 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
956 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
957 .priv_data_size = sizeof(MPVMainEncContext),
958 .init = ff_mpv_encode_init,
959 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),
960 .close = ff_mpv_encode_end,
961 };
962 #endif
963