Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/mpegpicture.c |
Date: | 2022-07-07 01:21:54 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 205 | 256 | 80.1% |
Branches: | 127 | 188 | 67.6% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Mpeg video formats-related picture management functions | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU Lesser General Public | ||
8 | * License as published by the Free Software Foundation; either | ||
9 | * version 2.1 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * FFmpeg is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | * Lesser General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU Lesser General Public | ||
17 | * License along with FFmpeg; if not, write to the Free Software | ||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
19 | */ | ||
20 | |||
21 | #include <stdint.h> | ||
22 | |||
23 | #include "libavutil/avassert.h" | ||
24 | #include "libavutil/common.h" | ||
25 | #include "libavutil/pixdesc.h" | ||
26 | #include "libavutil/imgutils.h" | ||
27 | |||
28 | #include "avcodec.h" | ||
29 | #include "encode.h" | ||
30 | #include "motion_est.h" | ||
31 | #include "mpegpicture.h" | ||
32 | #include "mpegutils.h" | ||
33 | #include "threadframe.h" | ||
34 | |||
35 | 31257 | static void av_noinline free_picture_tables(Picture *pic) | |
36 | { | ||
37 | 31257 | pic->alloc_mb_width = | |
38 | 31257 | pic->alloc_mb_height = 0; | |
39 | |||
40 | 31257 | av_buffer_unref(&pic->mb_var_buf); | |
41 | 31257 | av_buffer_unref(&pic->mc_mb_var_buf); | |
42 | 31257 | av_buffer_unref(&pic->mb_mean_buf); | |
43 | 31257 | av_buffer_unref(&pic->mbskip_table_buf); | |
44 | 31257 | av_buffer_unref(&pic->qscale_table_buf); | |
45 | 31257 | av_buffer_unref(&pic->mb_type_buf); | |
46 | |||
47 |
2/2✓ Branch 0 taken 62514 times.
✓ Branch 1 taken 31257 times.
|
93771 | for (int i = 0; i < 2; i++) { |
48 | 62514 | av_buffer_unref(&pic->motion_val_buf[i]); | |
49 | 62514 | av_buffer_unref(&pic->ref_index_buf[i]); | |
50 | } | ||
51 | 31257 | } | |
52 | |||
53 | 18752 | static int make_tables_writable(Picture *pic) | |
54 | { | ||
55 | int ret, i; | ||
56 | #define MAKE_WRITABLE(table) \ | ||
57 | do {\ | ||
58 | if (pic->table &&\ | ||
59 | (ret = av_buffer_make_writable(&pic->table)) < 0)\ | ||
60 | return ret;\ | ||
61 | } while (0) | ||
62 | |||
63 |
3/4✓ Branch 0 taken 8560 times.
✓ Branch 1 taken 10192 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8560 times.
|
18752 | MAKE_WRITABLE(mb_var_buf); |
64 |
3/4✓ Branch 0 taken 8560 times.
✓ Branch 1 taken 10192 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8560 times.
|
18752 | MAKE_WRITABLE(mc_mb_var_buf); |
65 |
3/4✓ Branch 0 taken 8560 times.
✓ Branch 1 taken 10192 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8560 times.
|
18752 | MAKE_WRITABLE(mb_mean_buf); |
66 |
2/4✓ Branch 0 taken 18752 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 18752 times.
|
18752 | MAKE_WRITABLE(mbskip_table_buf); |
67 |
2/4✓ Branch 0 taken 18752 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 18752 times.
|
18752 | MAKE_WRITABLE(qscale_table_buf); |
68 |
2/4✓ Branch 0 taken 18752 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 18752 times.
|
18752 | MAKE_WRITABLE(mb_type_buf); |
69 | |||
70 |
2/2✓ Branch 0 taken 37504 times.
✓ Branch 1 taken 18752 times.
|
56256 | for (i = 0; i < 2; i++) { |
71 |
3/4✓ Branch 0 taken 30176 times.
✓ Branch 1 taken 7328 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 30176 times.
|
37504 | MAKE_WRITABLE(motion_val_buf[i]); |
72 |
3/4✓ Branch 0 taken 30176 times.
✓ Branch 1 taken 7328 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 30176 times.
|
37504 | MAKE_WRITABLE(ref_index_buf[i]); |
73 | } | ||
74 | |||
75 | 18752 | return 0; | |
76 | } | ||
77 | |||
78 | 448 | int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, | |
79 | ScratchpadContext *sc, int linesize) | ||
80 | { | ||
81 | # define EMU_EDGE_HEIGHT (4 * 70) | ||
82 | 448 | int alloc_size = FFALIGN(FFABS(linesize) + 64, 32); | |
83 | |||
84 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 448 times.
|
448 | if (avctx->hwaccel) |
85 | ✗ | return 0; | |
86 | |||
87 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 448 times.
|
448 | if (linesize < 24) { |
88 | ✗ | av_log(avctx, AV_LOG_ERROR, "Image too small, temporary buffers cannot function\n"); | |
89 | ✗ | return AVERROR_PATCHWELCOME; | |
90 | } | ||
91 | |||
92 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 448 times.
|
448 | if (av_image_check_size2(alloc_size, EMU_EDGE_HEIGHT, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0) |
93 | ✗ | return AVERROR(ENOMEM); | |
94 | |||
95 | // edge emu needs blocksize + filter length - 1 | ||
96 | // (= 17x17 for halfpel / 21x21 for H.264) | ||
97 | // VC-1 computes luma and chroma simultaneously and needs 19X19 + 9x9 | ||
98 | // at uvlinesize. It supports only YUV420 so 24x24 is enough | ||
99 | // linesize * interlaced * MBsize | ||
100 | // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines | ||
101 |
1/2✓ Branch 1 taken 448 times.
✗ Branch 2 not taken.
|
448 | if (!FF_ALLOCZ_TYPED_ARRAY(sc->edge_emu_buffer, alloc_size * EMU_EDGE_HEIGHT) || |
102 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 448 times.
|
448 | !FF_ALLOCZ_TYPED_ARRAY(me->scratchpad, alloc_size * 4 * 16 * 2)) { |
103 | ✗ | av_freep(&sc->edge_emu_buffer); | |
104 | ✗ | return AVERROR(ENOMEM); | |
105 | } | ||
106 | |||
107 | 448 | me->temp = me->scratchpad; | |
108 | 448 | sc->rd_scratchpad = me->scratchpad; | |
109 | 448 | sc->b_scratchpad = me->scratchpad; | |
110 | 448 | sc->obmc_scratchpad = me->scratchpad + 16; | |
111 | |||
112 | 448 | return 0; | |
113 | } | ||
114 | |||
115 | /** | ||
116 | * Allocate a frame buffer | ||
117 | */ | ||
118 | 19416 | static int alloc_frame_buffer(AVCodecContext *avctx, Picture *pic, | |
119 | MotionEstContext *me, ScratchpadContext *sc, | ||
120 | int chroma_x_shift, int chroma_y_shift, | ||
121 | int linesize, int uvlinesize) | ||
122 | { | ||
123 | 19416 | int edges_needed = av_codec_is_encoder(avctx->codec); | |
124 | int r, ret; | ||
125 | |||
126 | 19416 | pic->tf.f = pic->f; | |
127 | |||
128 |
2/2✓ Branch 0 taken 8614 times.
✓ Branch 1 taken 10802 times.
|
19416 | if (edges_needed) { |
129 | 8614 | pic->f->width = avctx->width + 2 * EDGE_WIDTH; | |
130 | 8614 | pic->f->height = avctx->height + 2 * EDGE_WIDTH; | |
131 | |||
132 | 8614 | r = ff_encode_alloc_frame(avctx, pic->f); | |
133 |
1/2✓ Branch 0 taken 10802 times.
✗ Branch 1 not taken.
|
10802 | } else if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE && |
134 |
1/2✓ Branch 0 taken 10802 times.
✗ Branch 1 not taken.
|
10802 | avctx->codec_id != AV_CODEC_ID_VC1IMAGE && |
135 |
2/2✓ Branch 0 taken 10723 times.
✓ Branch 1 taken 79 times.
|
10802 | avctx->codec_id != AV_CODEC_ID_MSS2) { |
136 | 10723 | r = ff_thread_get_ext_buffer(avctx, &pic->tf, | |
137 | 10723 | pic->reference ? AV_GET_BUFFER_FLAG_REF : 0); | |
138 | } else { | ||
139 | 79 | pic->f->width = avctx->width; | |
140 | 79 | pic->f->height = avctx->height; | |
141 | 79 | pic->f->format = avctx->pix_fmt; | |
142 | 79 | r = avcodec_default_get_buffer2(avctx, pic->f, 0); | |
143 | } | ||
144 | |||
145 |
2/4✓ Branch 0 taken 19416 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19416 times.
|
19416 | if (r < 0 || !pic->f->buf[0]) { |
146 | ✗ | av_log(avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n", | |
147 | ✗ | r, pic->f->data[0]); | |
148 | ✗ | return -1; | |
149 | } | ||
150 | |||
151 |
2/2✓ Branch 0 taken 8614 times.
✓ Branch 1 taken 10802 times.
|
19416 | if (edges_needed) { |
152 | int i; | ||
153 |
2/2✓ Branch 0 taken 25842 times.
✓ Branch 1 taken 8614 times.
|
34456 | for (i = 0; pic->f->data[i]; i++) { |
154 |
2/2✓ Branch 0 taken 17228 times.
✓ Branch 1 taken 8614 times.
|
25842 | int offset = (EDGE_WIDTH >> (i ? chroma_y_shift : 0)) * |
155 | 25842 | pic->f->linesize[i] + | |
156 |
2/2✓ Branch 0 taken 17228 times.
✓ Branch 1 taken 8614 times.
|
25842 | (EDGE_WIDTH >> (i ? chroma_x_shift : 0)); |
157 | 25842 | pic->f->data[i] += offset; | |
158 | } | ||
159 | 8614 | pic->f->width = avctx->width; | |
160 | 8614 | pic->f->height = avctx->height; | |
161 | } | ||
162 | |||
163 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19416 times.
|
19416 | if (avctx->hwaccel) { |
164 | assert(!pic->hwaccel_picture_private); | ||
165 | ✗ | if (avctx->hwaccel->frame_priv_data_size) { | |
166 | ✗ | pic->hwaccel_priv_buf = av_buffer_allocz(avctx->hwaccel->frame_priv_data_size); | |
167 | ✗ | if (!pic->hwaccel_priv_buf) { | |
168 | ✗ | av_log(avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n"); | |
169 | ✗ | return -1; | |
170 | } | ||
171 | ✗ | pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data; | |
172 | } | ||
173 | } | ||
174 | |||
175 |
5/6✓ Branch 0 taken 19012 times.
✓ Branch 1 taken 404 times.
✓ Branch 2 taken 19012 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 19012 times.
✓ Branch 5 taken 404 times.
|
19416 | if ((linesize && linesize != pic->f->linesize[0]) || |
176 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19012 times.
|
19012 | (uvlinesize && uvlinesize != pic->f->linesize[1])) { |
177 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
178 | "get_buffer() failed (stride changed: linesize=%d/%d uvlinesize=%d/%d)\n", | ||
179 | ✗ | linesize, pic->f->linesize[0], | |
180 | ✗ | uvlinesize, pic->f->linesize[1]); | |
181 | ✗ | ff_mpeg_unref_picture(avctx, pic); | |
182 | ✗ | return -1; | |
183 | } | ||
184 | |||
185 |
1/2✓ Branch 1 taken 19416 times.
✗ Branch 2 not taken.
|
19416 | if (av_pix_fmt_count_planes(pic->f->format) > 2 && |
186 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19416 times.
|
19416 | pic->f->linesize[1] != pic->f->linesize[2]) { |
187 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
188 | "get_buffer() failed (uv stride mismatch)\n"); | ||
189 | ✗ | ff_mpeg_unref_picture(avctx, pic); | |
190 | ✗ | return -1; | |
191 | } | ||
192 | |||
193 |
3/4✓ Branch 0 taken 404 times.
✓ Branch 1 taken 19012 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 404 times.
|
19820 | if (!sc->edge_emu_buffer && |
194 | 404 | (ret = ff_mpeg_framesize_alloc(avctx, me, sc, | |
195 | 404 | pic->f->linesize[0])) < 0) { | |
196 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
197 | "get_buffer() failed to allocate context scratch buffers.\n"); | ||
198 | ✗ | ff_mpeg_unref_picture(avctx, pic); | |
199 | ✗ | return ret; | |
200 | } | ||
201 | |||
202 | 19416 | return 0; | |
203 | } | ||
204 | |||
205 | 1313 | static int alloc_picture_tables(AVCodecContext *avctx, Picture *pic, int encoding, int out_format, | |
206 | int mb_stride, int mb_width, int mb_height, int b8_stride) | ||
207 | { | ||
208 | 1313 | const int big_mb_num = mb_stride * (mb_height + 1) + 1; | |
209 | 1313 | const int mb_array_size = mb_stride * mb_height; | |
210 | 1313 | const int b8_array_size = b8_stride * mb_height * 2; | |
211 | int i; | ||
212 | |||
213 | |||
214 | 1313 | pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2); | |
215 | 1313 | pic->qscale_table_buf = av_buffer_allocz(big_mb_num + mb_stride); | |
216 | 1313 | pic->mb_type_buf = av_buffer_allocz((big_mb_num + mb_stride) * | |
217 | sizeof(uint32_t)); | ||
218 |
3/6✓ Branch 0 taken 1313 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1313 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1313 times.
|
1313 | if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf) |
219 | ✗ | return AVERROR(ENOMEM); | |
220 | |||
221 |
2/2✓ Branch 0 taken 703 times.
✓ Branch 1 taken 610 times.
|
1313 | if (encoding) { |
222 | 703 | pic->mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t)); | |
223 | 703 | pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t)); | |
224 | 703 | pic->mb_mean_buf = av_buffer_allocz(mb_array_size); | |
225 |
3/6✓ Branch 0 taken 703 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 703 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 703 times.
|
703 | if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf) |
226 | ✗ | return AVERROR(ENOMEM); | |
227 | } | ||
228 | |||
229 |
4/4✓ Branch 0 taken 525 times.
✓ Branch 1 taken 788 times.
✓ Branch 2 taken 180 times.
✓ Branch 3 taken 345 times.
|
1313 | if (out_format == FMT_H263 || encoding || |
230 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 180 times.
|
180 | (avctx->export_side_data & AV_CODEC_EXPORT_DATA_MVS)) { |
231 | 1133 | int mv_size = 2 * (b8_array_size + 4) * sizeof(int16_t); | |
232 | 1133 | int ref_index_size = 4 * mb_array_size; | |
233 | |||
234 |
3/4✓ Branch 0 taken 3399 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2266 times.
✓ Branch 3 taken 1133 times.
|
3399 | for (i = 0; mv_size && i < 2; i++) { |
235 | 2266 | pic->motion_val_buf[i] = av_buffer_allocz(mv_size); | |
236 | 2266 | pic->ref_index_buf[i] = av_buffer_allocz(ref_index_size); | |
237 |
2/4✓ Branch 0 taken 2266 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2266 times.
|
2266 | if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) |
238 | ✗ | return AVERROR(ENOMEM); | |
239 | } | ||
240 | } | ||
241 | |||
242 | 1313 | pic->alloc_mb_width = mb_width; | |
243 | 1313 | pic->alloc_mb_height = mb_height; | |
244 | 1313 | pic->alloc_mb_stride = mb_stride; | |
245 | |||
246 | 1313 | return 0; | |
247 | } | ||
248 | |||
249 | /** | ||
250 | * Allocate a Picture. | ||
251 | * The pixels are allocated/set by calling get_buffer() if shared = 0 | ||
252 | */ | ||
253 | 20065 | int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, | |
254 | ScratchpadContext *sc, int shared, int encoding, | ||
255 | int chroma_x_shift, int chroma_y_shift, int out_format, | ||
256 | int mb_stride, int mb_width, int mb_height, int b8_stride, | ||
257 | ptrdiff_t *linesize, ptrdiff_t *uvlinesize) | ||
258 | { | ||
259 | int i, ret; | ||
260 | |||
261 |
2/2✓ Branch 0 taken 18752 times.
✓ Branch 1 taken 1313 times.
|
20065 | if (pic->qscale_table_buf) |
262 |
1/2✓ Branch 0 taken 18752 times.
✗ Branch 1 not taken.
|
18752 | if ( pic->alloc_mb_width != mb_width |
263 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18752 times.
|
18752 | || pic->alloc_mb_height != mb_height) |
264 | ✗ | free_picture_tables(pic); | |
265 | |||
266 |
2/2✓ Branch 0 taken 649 times.
✓ Branch 1 taken 19416 times.
|
20065 | if (shared) { |
267 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 649 times.
|
649 | av_assert0(pic->f->data[0]); |
268 | 649 | pic->shared = 1; | |
269 | } else { | ||
270 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19416 times.
|
19416 | av_assert0(!pic->f->buf[0]); |
271 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19416 times.
|
19416 | if (alloc_frame_buffer(avctx, pic, me, sc, |
272 | chroma_x_shift, chroma_y_shift, | ||
273 | 19416 | *linesize, *uvlinesize) < 0) | |
274 | ✗ | return -1; | |
275 | |||
276 | 19416 | *linesize = pic->f->linesize[0]; | |
277 | 19416 | *uvlinesize = pic->f->linesize[1]; | |
278 | } | ||
279 | |||
280 |
2/2✓ Branch 0 taken 1313 times.
✓ Branch 1 taken 18752 times.
|
20065 | if (!pic->qscale_table_buf) |
281 | 1313 | ret = alloc_picture_tables(avctx, pic, encoding, out_format, | |
282 | mb_stride, mb_width, mb_height, b8_stride); | ||
283 | else | ||
284 | 18752 | ret = make_tables_writable(pic); | |
285 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 20065 times.
|
20065 | if (ret < 0) |
286 | ✗ | goto fail; | |
287 | |||
288 |
2/2✓ Branch 0 taken 9263 times.
✓ Branch 1 taken 10802 times.
|
20065 | if (encoding) { |
289 | 9263 | pic->mb_var = (uint16_t*)pic->mb_var_buf->data; | |
290 | 9263 | pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data; | |
291 | 9263 | pic->mb_mean = pic->mb_mean_buf->data; | |
292 | } | ||
293 | |||
294 | 20065 | pic->mbskip_table = pic->mbskip_table_buf->data; | |
295 | 20065 | pic->qscale_table = pic->qscale_table_buf->data + 2 * mb_stride + 1; | |
296 | 20065 | pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * mb_stride + 1; | |
297 | |||
298 |
2/2✓ Branch 0 taken 16221 times.
✓ Branch 1 taken 3844 times.
|
20065 | if (pic->motion_val_buf[0]) { |
299 |
2/2✓ Branch 0 taken 32442 times.
✓ Branch 1 taken 16221 times.
|
48663 | for (i = 0; i < 2; i++) { |
300 | 32442 | pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4; | |
301 | 32442 | pic->ref_index[i] = pic->ref_index_buf[i]->data; | |
302 | } | ||
303 | } | ||
304 | |||
305 | 20065 | return 0; | |
306 | ✗ | fail: | |
307 | ✗ | av_log(avctx, AV_LOG_ERROR, "Error allocating a picture.\n"); | |
308 | ✗ | ff_mpeg_unref_picture(avctx, pic); | |
309 | ✗ | free_picture_tables(pic); | |
310 | ✗ | return AVERROR(ENOMEM); | |
311 | } | ||
312 | |||
313 | /** | ||
314 | * Deallocate a picture; frees the picture tables in case they | ||
315 | * need to be reallocated anyway. | ||
316 | */ | ||
317 | 774049 | void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic) | |
318 | { | ||
319 | 774049 | int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean); | |
320 | |||
321 | 774049 | pic->tf.f = pic->f; | |
322 | /* WM Image / Screen codecs allocate internal buffers with different | ||
323 | * dimensions / colorspaces; ignore user-defined callbacks for these. */ | ||
324 |
1/2✓ Branch 0 taken 774049 times.
✗ Branch 1 not taken.
|
774049 | if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE && |
325 |
1/2✓ Branch 0 taken 774049 times.
✗ Branch 1 not taken.
|
774049 | avctx->codec_id != AV_CODEC_ID_VC1IMAGE && |
326 |
2/2✓ Branch 0 taken 767497 times.
✓ Branch 1 taken 6552 times.
|
774049 | avctx->codec_id != AV_CODEC_ID_MSS2) |
327 | 767497 | ff_thread_release_ext_buffer(avctx, &pic->tf); | |
328 |
1/2✓ Branch 0 taken 6552 times.
✗ Branch 1 not taken.
|
6552 | else if (pic->f) |
329 | 6552 | av_frame_unref(pic->f); | |
330 | |||
331 | 774049 | av_buffer_unref(&pic->hwaccel_priv_buf); | |
332 | |||
333 |
2/2✓ Branch 0 taken 1476 times.
✓ Branch 1 taken 772573 times.
|
774049 | if (pic->needs_realloc) |
334 | 1476 | free_picture_tables(pic); | |
335 | |||
336 | 774049 | memset((uint8_t*)pic + off, 0, sizeof(*pic) - off); | |
337 | 774049 | } | |
338 | |||
339 | 57604 | int ff_update_picture_tables(Picture *dst, const Picture *src) | |
340 | { | ||
341 | int i, ret; | ||
342 | |||
343 | 57604 | ret = av_buffer_replace(&dst->mb_var_buf, src->mb_var_buf); | |
344 | 57604 | ret |= av_buffer_replace(&dst->mc_mb_var_buf, src->mc_mb_var_buf); | |
345 | 57604 | ret |= av_buffer_replace(&dst->mb_mean_buf, src->mb_mean_buf); | |
346 | 57604 | ret |= av_buffer_replace(&dst->mbskip_table_buf, src->mbskip_table_buf); | |
347 | 57604 | ret |= av_buffer_replace(&dst->qscale_table_buf, src->qscale_table_buf); | |
348 | 57604 | ret |= av_buffer_replace(&dst->mb_type_buf, src->mb_type_buf); | |
349 |
2/2✓ Branch 0 taken 115208 times.
✓ Branch 1 taken 57604 times.
|
172812 | for (i = 0; i < 2; i++) { |
350 | 115208 | ret |= av_buffer_replace(&dst->motion_val_buf[i], src->motion_val_buf[i]); | |
351 | 115208 | ret |= av_buffer_replace(&dst->ref_index_buf[i], src->ref_index_buf[i]); | |
352 | } | ||
353 | |||
354 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57604 times.
|
57604 | if (ret < 0) { |
355 | ✗ | free_picture_tables(dst); | |
356 | ✗ | return ret; | |
357 | } | ||
358 | |||
359 | 57604 | dst->mb_var = src->mb_var; | |
360 | 57604 | dst->mc_mb_var = src->mc_mb_var; | |
361 | 57604 | dst->mb_mean = src->mb_mean; | |
362 | 57604 | dst->mbskip_table = src->mbskip_table; | |
363 | 57604 | dst->qscale_table = src->qscale_table; | |
364 | 57604 | dst->mb_type = src->mb_type; | |
365 |
2/2✓ Branch 0 taken 115208 times.
✓ Branch 1 taken 57604 times.
|
172812 | for (i = 0; i < 2; i++) { |
366 | 115208 | dst->motion_val[i] = src->motion_val[i]; | |
367 | 115208 | dst->ref_index[i] = src->ref_index[i]; | |
368 | } | ||
369 | |||
370 | 57604 | dst->alloc_mb_width = src->alloc_mb_width; | |
371 | 57604 | dst->alloc_mb_height = src->alloc_mb_height; | |
372 | 57604 | dst->alloc_mb_stride = src->alloc_mb_stride; | |
373 | |||
374 | 57604 | return 0; | |
375 | } | ||
376 | |||
377 | 57604 | int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src) | |
378 | { | ||
379 | int ret; | ||
380 | |||
381 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57604 times.
|
57604 | av_assert0(!dst->f->buf[0]); |
382 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57604 times.
|
57604 | av_assert0(src->f->buf[0]); |
383 | |||
384 | 57604 | src->tf.f = src->f; | |
385 | 57604 | dst->tf.f = dst->f; | |
386 | 57604 | ret = ff_thread_ref_frame(&dst->tf, &src->tf); | |
387 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57604 times.
|
57604 | if (ret < 0) |
388 | ✗ | goto fail; | |
389 | |||
390 | 57604 | ret = ff_update_picture_tables(dst, src); | |
391 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57604 times.
|
57604 | if (ret < 0) |
392 | ✗ | goto fail; | |
393 | |||
394 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 57604 times.
|
57604 | if (src->hwaccel_picture_private) { |
395 | ✗ | dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf); | |
396 | ✗ | if (!dst->hwaccel_priv_buf) { | |
397 | ✗ | ret = AVERROR(ENOMEM); | |
398 | ✗ | goto fail; | |
399 | } | ||
400 | ✗ | dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data; | |
401 | } | ||
402 | |||
403 | 57604 | dst->field_picture = src->field_picture; | |
404 | 57604 | dst->mb_var_sum = src->mb_var_sum; | |
405 | 57604 | dst->mc_mb_var_sum = src->mc_mb_var_sum; | |
406 | 57604 | dst->b_frame_score = src->b_frame_score; | |
407 | 57604 | dst->needs_realloc = src->needs_realloc; | |
408 | 57604 | dst->reference = src->reference; | |
409 | 57604 | dst->shared = src->shared; | |
410 | |||
411 | 57604 | memcpy(dst->encoding_error, src->encoding_error, | |
412 | sizeof(dst->encoding_error)); | ||
413 | |||
414 | 57604 | return 0; | |
415 | ✗ | fail: | |
416 | ✗ | ff_mpeg_unref_picture(avctx, dst); | |
417 | ✗ | return ret; | |
418 | } | ||
419 | |||
420 | 41707 | static inline int pic_is_unused(Picture *pic) | |
421 | { | ||
422 |
2/2✓ Branch 0 taken 19053 times.
✓ Branch 1 taken 22654 times.
|
41707 | if (!pic->f->buf[0]) |
423 | 19053 | return 1; | |
424 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 22634 times.
|
22654 | if (pic->needs_realloc) |
425 | 20 | return 1; | |
426 | 22634 | return 0; | |
427 | } | ||
428 | |||
429 | 19722 | static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared) | |
430 | { | ||
431 | int i; | ||
432 | |||
433 |
2/2✓ Branch 0 taken 649 times.
✓ Branch 1 taken 19073 times.
|
19722 | if (shared) { |
434 |
1/2✓ Branch 0 taken 852 times.
✗ Branch 1 not taken.
|
852 | for (i = 0; i < MAX_PICTURE_COUNT; i++) { |
435 |
2/2✓ Branch 0 taken 649 times.
✓ Branch 1 taken 203 times.
|
852 | if (!picture[i].f->buf[0]) |
436 | 649 | return i; | |
437 | } | ||
438 | } else { | ||
439 |
1/2✓ Branch 0 taken 41707 times.
✗ Branch 1 not taken.
|
41707 | for (i = 0; i < MAX_PICTURE_COUNT; i++) { |
440 |
2/2✓ Branch 1 taken 19073 times.
✓ Branch 2 taken 22634 times.
|
41707 | if (pic_is_unused(&picture[i])) |
441 | 19073 | return i; | |
442 | } | ||
443 | } | ||
444 | |||
445 | ✗ | av_log(avctx, AV_LOG_FATAL, | |
446 | "Internal error, picture buffer overflow\n"); | ||
447 | /* We could return -1, but the codec would crash trying to draw into a | ||
448 | * non-existing frame anyway. This is safer than waiting for a random crash. | ||
449 | * Also the return of this is never useful, an encoder must only allocate | ||
450 | * as much as allowed in the specification. This has no relationship to how | ||
451 | * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large | ||
452 | * enough for such valid streams). | ||
453 | * Plus, a decoder has to check stream validity and remove frames if too | ||
454 | * many reference frames are around. Waiting for "OOM" is not correct at | ||
455 | * all. Similarly, missing reference frames have to be replaced by | ||
456 | * interpolated/MC frames, anything else is a bug in the codec ... | ||
457 | */ | ||
458 | ✗ | abort(); | |
459 | return -1; | ||
460 | } | ||
461 | |||
462 | 19722 | int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared) | |
463 | { | ||
464 | 19722 | int ret = find_unused_picture(avctx, picture, shared); | |
465 | |||
466 |
2/4✓ Branch 0 taken 19722 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19722 times.
✗ Branch 3 not taken.
|
19722 | if (ret >= 0 && ret < MAX_PICTURE_COUNT) { |
467 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 19702 times.
|
19722 | if (picture[ret].needs_realloc) { |
468 | 20 | ff_mpeg_unref_picture(avctx, &picture[ret]); | |
469 | } | ||
470 | } | ||
471 | 19722 | return ret; | |
472 | } | ||
473 | |||
474 | 29781 | void av_cold ff_mpv_picture_free(AVCodecContext *avctx, Picture *pic) | |
475 | { | ||
476 | 29781 | free_picture_tables(pic); | |
477 | 29781 | ff_mpeg_unref_picture(avctx, pic); | |
478 | 29781 | av_frame_free(&pic->f); | |
479 | 29781 | } | |
480 |