FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/mpegvideo.c
Date: 2025-08-19 23:55:23
Exec Total Coverage
Lines: 254 290 87.6%
Functions: 16 18 88.9%
Branches: 114 148 77.0%
Line Branch Exec Source
1 /*
2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * 4MV & hq & B-frame encoding stuff by 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 * The simplest mpeg encoder (well, it was the simplest!).
28 */
29
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/intreadwrite.h"
35 #include "libavutil/mem.h"
36
37 #include "avcodec.h"
38 #include "blockdsp.h"
39 #include "idctdsp.h"
40 #include "mathops.h"
41 #include "mpeg_er.h"
42 #include "mpegutils.h"
43 #include "mpegvideo.h"
44 #include "mpegvideodata.h"
45 #include "mpegvideo_unquantize.h"
46 #include "libavutil/refstruct.h"
47
48
49 ✗ static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
50 {
51 ✗ while(h--)
52 ✗ memset(dst + h*linesize, 128, 16);
53 ✗ }
54
55 ✗ static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
56 {
57 ✗ while(h--)
58 ✗ memset(dst + h*linesize, 128, 8);
59 ✗ }
60
61 /* init common dct for both encoder and decoder */
62 802 static av_cold void dsp_init(MpegEncContext *s)
63 {
64 802 ff_blockdsp_init(&s->bdsp);
65 802 ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
66 802 ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
67
68
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 802 times.
 802 if (s->avctx->debug & FF_DEBUG_NOMC) {
69 int i;
70 ✗ for (i=0; i<4; i++) {
71 ✗ s->hdsp.avg_pixels_tab[0][i] = gray16;
72 ✗ s->hdsp.put_pixels_tab[0][i] = gray16;
73 ✗ s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
74
75 ✗ s->hdsp.avg_pixels_tab[1][i] = gray8;
76 ✗ s->hdsp.put_pixels_tab[1][i] = gray8;
77 ✗ s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
78 }
79 }
80 802 }
81
82 5456 av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st,
83 const uint8_t *src_scantable)
84 {
85 5456 st->scantable = src_scantable;
86
87
2/2
✓ Branch 0 taken 349184 times.
✓ Branch 1 taken 5456 times.
 354640 for (int i = 0, end = -1; i < 64; i++) {
88 349184 int j = src_scantable[i];
89 349184 st->permutated[i] = permutation[j];
90
2/2
✓ Branch 0 taken 102854 times.
✓ Branch 1 taken 246330 times.
 349184 if (permutation[j] > end)
91 102854 end = permutation[j];
92 349184 st->raster_end[i] = end;
93 }
94 5456 }
95
96 918 av_cold void ff_mpv_idct_init(MpegEncContext *s)
97 {
98
2/2
✓ Branch 0 taken 253 times.
✓ Branch 1 taken 665 times.
 918 if (s->codec_id == AV_CODEC_ID_MPEG4)
99 253 s->idsp.mpeg4_studio_profile = s->studio_profile;
100 918 ff_idctdsp_init(&s->idsp, s->avctx);
101
102 /* load & permutate scantables
103 * note: only wmv uses different ones
104 */
105
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 914 times.
 918 if (s->alternate_scan) {
106 4 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
107 4 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
108 } else {
109 914 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
110 914 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
111 }
112 918 ff_permute_scantable(s->permutated_intra_h_scantable, ff_alternate_horizontal_scan,
113 918 s->idsp.idct_permutation);
114 918 ff_permute_scantable(s->permutated_intra_v_scantable, ff_alternate_vertical_scan,
115 918 s->idsp.idct_permutation);
116 918 }
117
118 849 av_cold int ff_mpv_init_duplicate_contexts(MpegEncContext *s)
119 {
120 849 const int nb_slices = s->slice_context_count;
121 849 const size_t slice_size = s->slice_ctx_size;
122
123
2/2
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 849 times.
 931 for (int i = 1; i < nb_slices; i++) {
124 82 s->thread_context[i] = av_memdup(s, slice_size);
125
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 82 times.
 82 if (!s->thread_context[i])
126 ✗ return AVERROR(ENOMEM);
127 82 s->thread_context[i]->start_mb_y =
128 82 (s->mb_height * (i ) + nb_slices / 2) / nb_slices;
129 82 s->thread_context[i]->end_mb_y =
130 82 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
131 }
132 849 s->start_mb_y = 0;
133 872 s->end_mb_y = nb_slices > 1 ? (s->mb_height + nb_slices / 2) / nb_slices
134
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 826 times.
 849 : s->mb_height;
135 849 return 0;
136 }
137
138 1003 static av_cold void free_duplicate_context(MpegEncContext *s)
139 {
140
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1003 times.
 1003 if (!s)
141 ✗ return;
142
143 1003 av_freep(&s->sc.edge_emu_buffer);
144 1003 av_freep(&s->sc.scratchpad_buf);
145 1003 s->sc.obmc_scratchpad = NULL;
146 1003 s->sc.linesize = 0;
147 }
148
149 921 static av_cold void free_duplicate_contexts(MpegEncContext *s)
150 {
151
2/2
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 921 times.
 1003 for (int i = 1; i < s->slice_context_count; i++) {
152 82 free_duplicate_context(s->thread_context[i]);
153 82 av_freep(&s->thread_context[i]);
154 }
155 921 free_duplicate_context(s);
156 921 }
157
158 9932 int ff_update_duplicate_context(MpegEncContext *dst, const MpegEncContext *src)
159 {
160 #define COPY(M) \
161 M(ScratchpadContext, sc) \
162 M(int, start_mb_y) \
163 M(int, end_mb_y) \
164 M(int16_t*, dc_val) \
165 M(void*, ac_val)
166
167 int ret;
168 // FIXME copy only needed parts
169 #define BACKUP(T, member) T member = dst->member;
170 9932 COPY(BACKUP)
171 9932 memcpy(dst, src, sizeof(MpegEncContext));
172 #define RESTORE(T, member) dst->member = member;
173 9932 COPY(RESTORE)
174
175 9932 ret = ff_mpv_framesize_alloc(dst->avctx, &dst->sc, dst->linesize);
176
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9932 times.
 9932 if (ret < 0) {
177 ✗ av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
178 "scratch buffers.\n");
179 ✗ return ret;
180 }
181 9932 return 0;
182 }
183
184 /**
185 * Set the given MpegEncContext to common defaults
186 * (same for encoding and decoding).
187 * The changed fields will not depend upon the
188 * prior state of the MpegEncContext.
189 */
190 840 av_cold void ff_mpv_common_defaults(MpegEncContext *s)
191 {
192 840 s->chroma_qscale_table = ff_default_chroma_qscale_table;
193 840 s->progressive_frame = 1;
194 840 s->progressive_sequence = 1;
195 840 s->picture_structure = PICT_FRAME;
196
197 840 s->slice_context_count = 1;
198 840 }
199
200 921 static av_cold void free_buffer_pools(BufferPoolContext *pools)
201 {
202 921 av_refstruct_pool_uninit(&pools->mbskip_table_pool);
203 921 av_refstruct_pool_uninit(&pools->qscale_table_pool);
204 921 av_refstruct_pool_uninit(&pools->mb_type_pool);
205 921 av_refstruct_pool_uninit(&pools->motion_val_pool);
206 921 av_refstruct_pool_uninit(&pools->ref_index_pool);
207 921 pools->alloc_mb_height = pools->alloc_mb_width = pools->alloc_mb_stride = 0;
208 921 }
209
210 849 av_cold int ff_mpv_init_context_frame(MpegEncContext *s)
211 {
212 849 int nb_slices = (HAVE_THREADS &&
213 849 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
214
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 826 times.
 849 s->avctx->thread_count : 1;
215 849 BufferPoolContext *const pools = &s->buffer_pools;
216 int y_size, c_size, yc_size, mb_array_size, mv_table_size, x, y;
217 int mb_height;
218
219
4/4
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 645 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 192 times.
 849 if (s->encoding && s->avctx->slices)
220 12 nb_slices = s->avctx->slices;
221
222
4/4
✓ Branch 0 taken 282 times.
✓ Branch 1 taken 567 times.
✓ Branch 2 taken 161 times.
✓ Branch 3 taken 121 times.
 849 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
223 161 s->mb_height = (s->height + 31) / 32 * 2;
224 else
225 688 s->mb_height = (s->height + 15) / 16;
226
227
5/6
✓ Branch 0 taken 849 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 836 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 12 times.
 849 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
228 int max_slices;
229
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (s->mb_height)
230 1 max_slices = FFMIN(MAX_THREADS, s->mb_height);
231 else
232 ✗ max_slices = MAX_THREADS;
233 1 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
234 " reducing to %d\n", nb_slices, max_slices);
235 1 nb_slices = max_slices;
236 }
237
238 849 s->slice_context_count = nb_slices;
239
240 /* VC-1 can change from being progressive to interlaced on a per-frame
241 * basis. We therefore allocate certain buffers so big that they work
242 * in both instances. */
243 1698 mb_height = s->msmpeg4_version == MSMP4_VC1 ?
244
2/2
✓ Branch 0 taken 34 times.
✓ Branch 1 taken 815 times.
 849 FFALIGN(s->mb_height, 2) : s->mb_height;
245
246 849 s->mb_width = (s->width + 15) / 16;
247 849 s->mb_stride = s->mb_width + 1;
248 849 s->b8_stride = s->mb_width * 2 + 1;
249 849 mb_array_size = mb_height * s->mb_stride;
250 849 mv_table_size = (mb_height + 2) * s->mb_stride + 1;
251
252 /* set default edge pos, will be overridden
253 * in decode_header if needed */
254 849 s->h_edge_pos = s->mb_width * 16;
255 849 s->v_edge_pos = s->mb_height * 16;
256
257 849 s->mb_num = s->mb_width * s->mb_height;
258
259 849 s->block_wrap[0] =
260 849 s->block_wrap[1] =
261 849 s->block_wrap[2] =
262 849 s->block_wrap[3] = s->b8_stride;
263 849 s->block_wrap[4] =
264 849 s->block_wrap[5] = s->mb_stride;
265
266 849 y_size = s->b8_stride * (2 * mb_height + 1);
267 849 c_size = s->mb_stride * (mb_height + 1);
268 849 yc_size = y_size + 2 * c_size;
269
270
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 849 times.
 849 if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_index2xy, s->mb_num + 1))
271 ✗ return AVERROR(ENOMEM);
272
2/2
✓ Branch 0 taken 17103 times.
✓ Branch 1 taken 849 times.
 17952 for (y = 0; y < s->mb_height; y++)
273
2/2
✓ Branch 0 taken 555243 times.
✓ Branch 1 taken 17103 times.
 572346 for (x = 0; x < s->mb_width; x++)
274 555243 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
275
276 849 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
277
278 #define ALLOC_POOL(name, size, flags) do { \
279 pools->name ##_pool = av_refstruct_pool_alloc((size), (flags)); \
280 if (!pools->name ##_pool) \
281 return AVERROR(ENOMEM); \
282 } while (0)
283
284
2/2
✓ Branch 0 taken 570 times.
✓ Branch 1 taken 279 times.
 849 if (s->codec_id == AV_CODEC_ID_MPEG4 ||
285
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 554 times.
 570 (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
286 /* interlaced direct mode decoding tables */
287 295 int16_t (*tmp)[2] = av_calloc(mv_table_size, 4 * sizeof(*tmp));
288
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 295 times.
 295 if (!tmp)
289 ✗ return AVERROR(ENOMEM);
290 295 s->p_field_mv_table_base = tmp;
291 295 tmp += s->mb_stride + 1;
292
2/2
✓ Branch 0 taken 590 times.
✓ Branch 1 taken 295 times.
 885 for (int i = 0; i < 2; i++) {
293
2/2
✓ Branch 0 taken 1180 times.
✓ Branch 1 taken 590 times.
 1770 for (int j = 0; j < 2; j++) {
294 1180 s->p_field_mv_table[i][j] = tmp;
295 1180 tmp += mv_table_size;
296 }
297 }
298
2/2
✓ Branch 0 taken 279 times.
✓ Branch 1 taken 16 times.
 295 if (s->codec_id == AV_CODEC_ID_MPEG4) {
299
3/4
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 63 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 279 times.
 279 ALLOC_POOL(mbskip_table, mb_array_size + 2,
300 !s->encoding ? AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME : 0);
301
2/2
✓ Branch 0 taken 216 times.
✓ Branch 1 taken 63 times.
 279 if (!s->encoding) {
302 /* cbp, pred_dir */
303
1/2
✓ Branch 1 taken 216 times.
✗ Branch 2 not taken.
 216 if (!(s->cbp_table = av_mallocz(mb_array_size)) ||
304
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 216 times.
 216 !(s->pred_dir_table = av_mallocz(mb_array_size)))
305 ✗ return AVERROR(ENOMEM);
306 }
307 }
308 }
309
310
2/2
✓ Branch 0 taken 81 times.
✓ Branch 1 taken 768 times.
 849 if (s->msmpeg4_version >= MSMP4_V3) {
311 81 s->coded_block_base = av_mallocz(y_size);
312
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 81 times.
 81 if (!s->coded_block_base)
313 ✗ return AVERROR(ENOMEM);
314 81 s->coded_block = s->coded_block_base + s->b8_stride + 1;
315 }
316
317
6/6
✓ Branch 0 taken 474 times.
✓ Branch 1 taken 375 times.
✓ Branch 2 taken 461 times.
✓ Branch 3 taken 13 times.
✓ Branch 4 taken 343 times.
✓ Branch 5 taken 118 times.
 849 if (s->h263_pred || s->h263_aic || !s->encoding) {
318 // When encoding, each slice (and therefore each thread)
319 // gets its own ac_val and dc_val buffers in order to avoid
320 // races.
321
2/2
✓ Branch 0 taken 86 times.
✓ Branch 1 taken 645 times.
 731 size_t allslice_yc_size = yc_size * (s->encoding ? nb_slices : 1);
322
2/2
✓ Branch 0 taken 462 times.
✓ Branch 1 taken 269 times.
 731 if (s->out_format == FMT_H263) {
323 /* ac values */
324
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 462 times.
 462 if (!FF_ALLOCZ_TYPED_ARRAY(s->ac_val_base, allslice_yc_size))
325 ✗ return AVERROR(ENOMEM);
326 462 s->ac_val = s->ac_val_base + s->b8_stride + 1;
327 }
328
329 /* dc values */
330 // MN: we need these for error resilience of intra-frames
331 // Allocating them unconditionally for decoders also means
332 // that we don't need to reinitialize when e.g. h263_aic changes.
333
334 // y_size and therefore yc_size is always odd; allocate one element
335 // more for each encoder slice in order to be able to align each slice's
336 // dc_val to four in order to use aligned stores when cleaning dc_val.
337 731 allslice_yc_size += s->encoding * nb_slices;
338
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 731 times.
 731 if (!FF_ALLOC_TYPED_ARRAY(s->dc_val_base, allslice_yc_size))
339 ✗ return AVERROR(ENOMEM);
340 731 s->dc_val = s->dc_val_base + s->b8_stride + 1;
341
2/2
✓ Branch 0 taken 3192415 times.
✓ Branch 1 taken 731 times.
 3193146 for (size_t i = 0; i < allslice_yc_size; ++i)
342 3192415 s->dc_val_base[i] = 1024;
343 }
344
345 // Note the + 1 is for a quicker MPEG-4 slice_end detection
346
1/2
✓ Branch 1 taken 849 times.
✗ Branch 2 not taken.
 849 if (!(s->mbskip_table = av_mallocz(mb_array_size + 2)) ||
347 /* which mb is an intra block, init macroblock skip table */
348
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 849 times.
 849 !(s->mbintra_table = av_mallocz(mb_array_size)))
349 ✗ return AVERROR(ENOMEM);
350
351
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 849 times.
 849 ALLOC_POOL(qscale_table, mv_table_size, 0);
352
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 849 times.
 849 ALLOC_POOL(mb_type, mv_table_size * sizeof(uint32_t), 0);
353
354
4/4
✓ Branch 0 taken 370 times.
✓ Branch 1 taken 479 times.
✓ Branch 2 taken 269 times.
✓ Branch 3 taken 101 times.
 849 if (s->out_format == FMT_H263 || s->encoding ||
355
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 269 times.
 269 (s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_MVS)) {
356 580 const int b8_array_size = s->b8_stride * mb_height * 2;
357 580 int mv_size = 2 * (b8_array_size + 4) * sizeof(int16_t);
358 580 int ref_index_size = 4 * mb_array_size;
359
360 /* FIXME: The output of H.263 with OBMC depends upon
361 * the earlier content of the buffer; therefore we set
362 * the flags to always reset returned buffers here. */
363
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 580 times.
 580 ALLOC_POOL(motion_val, mv_size, AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME);
364
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 580 times.
 580 ALLOC_POOL(ref_index, ref_index_size, 0);
365 }
366 #undef ALLOC_POOL
367 849 pools->alloc_mb_width = s->mb_width;
368 849 pools->alloc_mb_height = mb_height;
369 849 pools->alloc_mb_stride = s->mb_stride;
370
371
2/2
✓ Branch 0 taken 645 times.
✓ Branch 1 taken 204 times.
 849 return !CONFIG_MPEGVIDEODEC || s->encoding ? 0 : ff_mpeg_er_init(s);
372 }
373
374 /**
375 * init common structure for both encoder and decoder.
376 * this assumes that some variables like width/height are already set
377 */
378 802 av_cold int ff_mpv_common_init(MpegEncContext *s)
379 {
380 int ret;
381
382
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 802 times.
 802 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
383 ✗ av_log(s->avctx, AV_LOG_ERROR,
384 "decoding to AV_PIX_FMT_NONE is not supported.\n");
385 ✗ return AVERROR(EINVAL);
386 }
387
388
4/6
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 790 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 790 times.
 1592 if ((s->width || s->height) &&
389 790 av_image_check_size(s->width, s->height, 0, s->avctx))
390 ✗ return AVERROR(EINVAL);
391
392 802 dsp_init(s);
393
394 /* set chroma shifts */
395 802 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
396 &s->chroma_x_shift,
397 &s->chroma_y_shift);
398
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 802 times.
 802 if (ret)
399 ✗ return ret;
400
401
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 802 times.
 802 if ((ret = ff_mpv_init_context_frame(s)))
402 ✗ goto fail;
403
404 802 s->context_initialized = 1;
405 802 s->thread_context[0] = s;
406
407 // if (s->width && s->height) {
408
2/2
✓ Branch 0 taken 598 times.
✓ Branch 1 taken 204 times.
 802 if (!s->encoding) {
409 598 ret = ff_mpv_init_duplicate_contexts(s);
410
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 598 times.
 598 if (ret < 0)
411 ✗ goto fail;
412 }
413 // }
414
415 802 return 0;
416 ✗ fail:
417 ✗ ff_mpv_common_end(s);
418 ✗ return ret;
419 }
420
421 921 av_cold void ff_mpv_free_context_frame(MpegEncContext *s)
422 {
423 921 free_duplicate_contexts(s);
424
425 921 free_buffer_pools(&s->buffer_pools);
426 921 av_freep(&s->p_field_mv_table_base);
427
2/2
✓ Branch 0 taken 1842 times.
✓ Branch 1 taken 921 times.
 2763 for (int i = 0; i < 2; i++)
428
2/2
✓ Branch 0 taken 3684 times.
✓ Branch 1 taken 1842 times.
 5526 for (int j = 0; j < 2; j++)
429 3684 s->p_field_mv_table[i][j] = NULL;
430
431 921 av_freep(&s->ac_val_base);
432 921 av_freep(&s->dc_val_base);
433 921 av_freep(&s->coded_block_base);
434 921 av_freep(&s->mbintra_table);
435 921 av_freep(&s->cbp_table);
436 921 av_freep(&s->pred_dir_table);
437
438 921 av_freep(&s->mbskip_table);
439
440 921 av_freep(&s->er.error_status_table);
441 921 av_freep(&s->er.er_temp_buffer);
442 921 av_freep(&s->mb_index2xy);
443
444 921 s->linesize = s->uvlinesize = 0;
445 921 }
446
447 874 av_cold void ff_mpv_common_end(MpegEncContext *s)
448 {
449 874 ff_mpv_free_context_frame(s);
450
2/2
✓ Branch 0 taken 23 times.
✓ Branch 1 taken 851 times.
 874 if (s->slice_context_count > 1)
451 23 s->slice_context_count = 1;
452
453 874 ff_mpv_unref_picture(&s->last_pic);
454 874 ff_mpv_unref_picture(&s->cur_pic);
455 874 ff_mpv_unref_picture(&s->next_pic);
456
457 874 s->context_initialized = 0;
458 874 s->context_reinit = 0;
459 874 s->linesize = s->uvlinesize = 0;
460 874 }
461
462
463 /**
464 * Clean dc, ac for the current non-intra MB.
465 */
466 394875 void ff_clean_intra_table_entries(MpegEncContext *s)
467 {
468 394875 int wrap = s->b8_stride;
469 394875 int xy = s->block_index[0];
470 /* chroma */
471 394875 unsigned uxy = s->block_index[4];
472 394875 unsigned vxy = s->block_index[5];
473 394875 int16_t *dc_val = s->dc_val;
474
475 394875 AV_WN32A(dc_val + xy, 1024 << 16 | 1024);
476 394875 AV_WN32 (dc_val + xy + wrap, 1024 << 16 | 1024);
477 394875 dc_val[uxy] =
478 394875 dc_val[vxy] = 1024;
479 /* ac pred */
480 394875 int16_t (*ac_val)[16] = s->ac_val;
481
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 394875 times.
 394875 av_assume(!((uintptr_t)ac_val & 0xF));
482 // Don't reset the upper-left luma block, as it will only ever be
483 // referenced by blocks from the same macroblock.
484 394875 memset(ac_val[xy + 1], 0, sizeof(*ac_val));
485 394875 memset(ac_val[xy + wrap], 0, 2 * sizeof(*ac_val));
486 /* ac pred */
487 394875 memset(ac_val[uxy], 0, sizeof(*ac_val));
488 394875 memset(ac_val[vxy], 0, sizeof(*ac_val));
489 394875 }
490
491 853016 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
492 853016 const int linesize = s->cur_pic.linesize[0]; //not s->linesize as this would be wrong for field pics
493 853016 const int uvlinesize = s->cur_pic.linesize[1];
494
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 852986 times.
 853016 const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
495 853016 const int height_of_mb = 4 - s->avctx->lowres;
496
497 853016 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
498 853016 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
499 853016 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
500 853016 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
501 853016 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
502 853016 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
503 //block_index is not used by mpeg2, so it is not affected by chroma_format
504
505 853016 s->dest[0] = s->cur_pic.data[0] + (int)((s->mb_x - 1U) << width_of_mb);
506 853016 s->dest[1] = s->cur_pic.data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
507 853016 s->dest[2] = s->cur_pic.data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
508
509
2/2
✓ Branch 0 taken 812862 times.
✓ Branch 1 taken 40154 times.
 853016 if (s->picture_structure == PICT_FRAME) {
510 812862 s->dest[0] += s->mb_y * linesize << height_of_mb;
511 812862 s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
512 812862 s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
513 } else {
514 40154 s->dest[0] += (s->mb_y>>1) * linesize << height_of_mb;
515 40154 s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
516 40154 s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
517 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
518 }
519 853016 }
520
521 /**
522 * set qscale and update qscale dependent variables.
523 */
524 1454638 void ff_set_qscale(MpegEncContext * s, int qscale)
525 {
526
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1454637 times.
 1454638 if (qscale < 1)
527 1 qscale = 1;
528
2/2
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 1454608 times.
 1454637 else if (qscale > 31)
529 29 qscale = 31;
530
531 1454638 s->qscale = qscale;
532 1454638 s->chroma_qscale= s->chroma_qscale_table[qscale];
533
534 1454638 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
535 1454638 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
536 1454638 }
537