FFmpeg coverage

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