GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mpegpicture.c Lines: 198 248 79.8 %
Date: 2019-11-18 18:00:01 Branches: 180 252 71.4 %

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 "motion_est.h"
30
#include "mpegpicture.h"
31
#include "mpegutils.h"
32
33
18551
static int make_tables_writable(Picture *pic)
34
{
35
    int ret, i;
36
#define MAKE_WRITABLE(table) \
37
do {\
38
    if (pic->table &&\
39
       (ret = av_buffer_make_writable(&pic->table)) < 0)\
40
    return ret;\
41
} while (0)
42
43

18551
    MAKE_WRITABLE(mb_var_buf);
44

18551
    MAKE_WRITABLE(mc_mb_var_buf);
45

18551
    MAKE_WRITABLE(mb_mean_buf);
46

18551
    MAKE_WRITABLE(mbskip_table_buf);
47

18551
    MAKE_WRITABLE(qscale_table_buf);
48

18551
    MAKE_WRITABLE(mb_type_buf);
49
50
55653
    for (i = 0; i < 2; i++) {
51

37102
        MAKE_WRITABLE(motion_val_buf[i]);
52

37102
        MAKE_WRITABLE(ref_index_buf[i]);
53
    }
54
55
18551
    return 0;
56
}
57
58
433
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me,
59
                            ScratchpadContext *sc, int linesize)
60
{
61
#   define EMU_EDGE_HEIGHT (4 * 70)
62
433
    int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
63
64
433
    if (avctx->hwaccel)
65
        return 0;
66
67
433
    if (linesize < 24) {
68
        av_log(avctx, AV_LOG_ERROR, "Image too small, temporary buffers cannot function\n");
69
        return AVERROR_PATCHWELCOME;
70
    }
71
72
433
    if (av_image_check_size2(alloc_size, EMU_EDGE_HEIGHT, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)
73
        return AVERROR(ENOMEM);
74
75
    // edge emu needs blocksize + filter length - 1
76
    // (= 17x17 for  halfpel / 21x21 for H.264)
77
    // VC-1 computes luma and chroma simultaneously and needs 19X19 + 9x9
78
    // at uvlinesize. It supports only YUV420 so 24x24 is enough
79
    // linesize * interlaced * MBsize
80
    // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines
81
433
    FF_ALLOCZ_ARRAY_OR_GOTO(avctx, sc->edge_emu_buffer, alloc_size, EMU_EDGE_HEIGHT,
82
                      fail);
83
84
433
    FF_ALLOCZ_ARRAY_OR_GOTO(avctx, me->scratchpad, alloc_size, 4 * 16 * 2,
85
                      fail)
86
433
    me->temp            = me->scratchpad;
87
433
    sc->rd_scratchpad   = me->scratchpad;
88
433
    sc->b_scratchpad    = me->scratchpad;
89
433
    sc->obmc_scratchpad = me->scratchpad + 16;
90
91
433
    return 0;
92
fail:
93
    av_freep(&sc->edge_emu_buffer);
94
    return AVERROR(ENOMEM);
95
}
96
97
/**
98
 * Allocate a frame buffer
99
 */
100
19190
static int alloc_frame_buffer(AVCodecContext *avctx,  Picture *pic,
101
                              MotionEstContext *me, ScratchpadContext *sc,
102
                              int chroma_x_shift, int chroma_y_shift,
103
                              int linesize, int uvlinesize)
104
{
105
19190
    int edges_needed = av_codec_is_encoder(avctx->codec);
106
    int r, ret;
107
108
19190
    pic->tf.f = pic->f;
109
19190
    if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE &&
110
19190
        avctx->codec_id != AV_CODEC_ID_VC1IMAGE  &&
111
19190
        avctx->codec_id != AV_CODEC_ID_MSS2) {
112
19111
        if (edges_needed) {
113
8358
            pic->f->width  = avctx->width  + 2 * EDGE_WIDTH;
114
8358
            pic->f->height = avctx->height + 2 * EDGE_WIDTH;
115
        }
116
117
19111
        r = ff_thread_get_buffer(avctx, &pic->tf,
118
19111
                                 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
119
    } else {
120
79
        pic->f->width  = avctx->width;
121
79
        pic->f->height = avctx->height;
122
79
        pic->f->format = avctx->pix_fmt;
123
79
        r = avcodec_default_get_buffer2(avctx, pic->f, 0);
124
    }
125
126

19190
    if (r < 0 || !pic->f->buf[0]) {
127
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
128
               r, pic->f->data[0]);
129
        return -1;
130
    }
131
132
19190
    if (edges_needed) {
133
        int i;
134
33432
        for (i = 0; pic->f->data[i]; i++) {
135
25074
            int offset = (EDGE_WIDTH >> (i ? chroma_y_shift : 0)) *
136
25074
                         pic->f->linesize[i] +
137
25074
                         (EDGE_WIDTH >> (i ? chroma_x_shift : 0));
138
25074
            pic->f->data[i] += offset;
139
        }
140
8358
        pic->f->width  = avctx->width;
141
8358
        pic->f->height = avctx->height;
142
    }
143
144
19190
    if (avctx->hwaccel) {
145
        assert(!pic->hwaccel_picture_private);
146
        if (avctx->hwaccel->frame_priv_data_size) {
147
            pic->hwaccel_priv_buf = av_buffer_allocz(avctx->hwaccel->frame_priv_data_size);
148
            if (!pic->hwaccel_priv_buf) {
149
                av_log(avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
150
                return -1;
151
            }
152
            pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
153
        }
154
    }
155
156

19190
    if ((linesize   &&   linesize != pic->f->linesize[0]) ||
157
18793
        (uvlinesize && uvlinesize != pic->f->linesize[1])) {
158
        av_log(avctx, AV_LOG_ERROR,
159
               "get_buffer() failed (stride changed: linesize=%d/%d uvlinesize=%d/%d)\n",
160
               linesize,   pic->f->linesize[0],
161
               uvlinesize, pic->f->linesize[1]);
162
        ff_mpeg_unref_picture(avctx, pic);
163
        return -1;
164
    }
165
166
19190
    if (av_pix_fmt_count_planes(pic->f->format) > 2 &&
167
19190
        pic->f->linesize[1] != pic->f->linesize[2]) {
168
        av_log(avctx, AV_LOG_ERROR,
169
               "get_buffer() failed (uv stride mismatch)\n");
170
        ff_mpeg_unref_picture(avctx, pic);
171
        return -1;
172
    }
173
174

19587
    if (!sc->edge_emu_buffer &&
175
397
        (ret = ff_mpeg_framesize_alloc(avctx, me, sc,
176
397
                                       pic->f->linesize[0])) < 0) {
177
        av_log(avctx, AV_LOG_ERROR,
178
               "get_buffer() failed to allocate context scratch buffers.\n");
179
        ff_mpeg_unref_picture(avctx, pic);
180
        return ret;
181
    }
182
183
19190
    return 0;
184
}
185
186
1288
static int alloc_picture_tables(AVCodecContext *avctx, Picture *pic, int encoding, int out_format,
187
                                int mb_stride, int mb_width, int mb_height, int b8_stride)
188
{
189
1288
    const int big_mb_num    = mb_stride * (mb_height + 1) + 1;
190
1288
    const int mb_array_size = mb_stride * mb_height;
191
1288
    const int b8_array_size = b8_stride * mb_height * 2;
192
    int i;
193
194
195
1288
    pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
196
1288
    pic->qscale_table_buf = av_buffer_allocz(big_mb_num + mb_stride);
197
1288
    pic->mb_type_buf      = av_buffer_allocz((big_mb_num + mb_stride) *
198
                                             sizeof(uint32_t));
199

1288
    if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
200
        return AVERROR(ENOMEM);
201
202
1288
    if (encoding) {
203
687
        pic->mb_var_buf    = av_buffer_allocz(mb_array_size * sizeof(int16_t));
204
687
        pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
205
687
        pic->mb_mean_buf   = av_buffer_allocz(mb_array_size);
206

687
        if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
207
            return AVERROR(ENOMEM);
208
    }
209
210

1288
    if (out_format == FMT_H263 || encoding ||
211
#if FF_API_DEBUG_MV
212
        avctx->debug_mv ||
213
#endif
214
184
        (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS)) {
215
1104
        int mv_size        = 2 * (b8_array_size + 4) * sizeof(int16_t);
216
1104
        int ref_index_size = 4 * mb_array_size;
217
218

3312
        for (i = 0; mv_size && i < 2; i++) {
219
2208
            pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
220
2208
            pic->ref_index_buf[i]  = av_buffer_allocz(ref_index_size);
221

2208
            if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
222
                return AVERROR(ENOMEM);
223
        }
224
    }
225
226
1288
    pic->alloc_mb_width  = mb_width;
227
1288
    pic->alloc_mb_height = mb_height;
228
229
1288
    return 0;
230
}
231
232
/**
233
 * Allocate a Picture.
234
 * The pixels are allocated/set by calling get_buffer() if shared = 0
235
 */
236
19839
int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me,
237
                     ScratchpadContext *sc, int shared, int encoding,
238
                     int chroma_x_shift, int chroma_y_shift, int out_format,
239
                     int mb_stride, int mb_width, int mb_height, int b8_stride,
240
                     ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
241
{
242
    int i, ret;
243
244
19839
    if (pic->qscale_table_buf)
245
18551
        if (   pic->alloc_mb_width  != mb_width
246
18551
            || pic->alloc_mb_height != mb_height)
247
            ff_free_picture_tables(pic);
248
249
19839
    if (shared) {
250
649
        av_assert0(pic->f->data[0]);
251
649
        pic->shared = 1;
252
    } else {
253
19190
        av_assert0(!pic->f->buf[0]);
254
19190
        if (alloc_frame_buffer(avctx, pic, me, sc,
255
                               chroma_x_shift, chroma_y_shift,
256
19190
                               *linesize, *uvlinesize) < 0)
257
            return -1;
258
259
19190
        *linesize   = pic->f->linesize[0];
260
19190
        *uvlinesize = pic->f->linesize[1];
261
    }
262
263
19839
    if (!pic->qscale_table_buf)
264
1288
        ret = alloc_picture_tables(avctx, pic, encoding, out_format,
265
                                   mb_stride, mb_width, mb_height, b8_stride);
266
    else
267
18551
        ret = make_tables_writable(pic);
268
19839
    if (ret < 0)
269
        goto fail;
270
271
19839
    if (encoding) {
272
9007
        pic->mb_var    = (uint16_t*)pic->mb_var_buf->data;
273
9007
        pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
274
9007
        pic->mb_mean   = pic->mb_mean_buf->data;
275
    }
276
277
19839
    pic->mbskip_table = pic->mbskip_table_buf->data;
278
19839
    pic->qscale_table = pic->qscale_table_buf->data + 2 * mb_stride + 1;
279
19839
    pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * mb_stride + 1;
280
281
19839
    if (pic->motion_val_buf[0]) {
282
48138
        for (i = 0; i < 2; i++) {
283
32092
            pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
284
32092
            pic->ref_index[i]  = pic->ref_index_buf[i]->data;
285
        }
286
    }
287
288
19839
    return 0;
289
fail:
290
    av_log(avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
291
    ff_mpeg_unref_picture(avctx, pic);
292
    ff_free_picture_tables(pic);
293
    return AVERROR(ENOMEM);
294
}
295
296
/**
297
 * Deallocate a picture.
298
 */
299
785046
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
300
{
301
785046
    int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
302
303
785046
    pic->tf.f = pic->f;
304
    /* WM Image / Screen codecs allocate internal buffers with different
305
     * dimensions / colorspaces; ignore user-defined callbacks for these. */
306
785046
    if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE &&
307
785046
        avctx->codec_id != AV_CODEC_ID_VC1IMAGE  &&
308
785046
        avctx->codec_id != AV_CODEC_ID_MSS2)
309
778484
        ff_thread_release_buffer(avctx, &pic->tf);
310
6562
    else if (pic->f)
311
6562
        av_frame_unref(pic->f);
312
313
785046
    av_buffer_unref(&pic->hwaccel_priv_buf);
314
315
785046
    if (pic->needs_realloc)
316
1348
        ff_free_picture_tables(pic);
317
318
785046
    memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
319
785046
}
320
321
73674
int ff_update_picture_tables(Picture *dst, Picture *src)
322
{
323
     int i;
324
325
#define UPDATE_TABLE(table)                                                   \
326
do {                                                                          \
327
    if (src->table &&                                                         \
328
        (!dst->table || dst->table->buffer != src->table->buffer)) {          \
329
        av_buffer_unref(&dst->table);                                         \
330
        dst->table = av_buffer_ref(src->table);                               \
331
        if (!dst->table) {                                                    \
332
            ff_free_picture_tables(dst);                                      \
333
            return AVERROR(ENOMEM);                                           \
334
        }                                                                     \
335
    }                                                                         \
336
} while (0)
337
338


73674
    UPDATE_TABLE(mb_var_buf);
339


73674
    UPDATE_TABLE(mc_mb_var_buf);
340


73674
    UPDATE_TABLE(mb_mean_buf);
341


73674
    UPDATE_TABLE(mbskip_table_buf);
342


73674
    UPDATE_TABLE(qscale_table_buf);
343


73674
    UPDATE_TABLE(mb_type_buf);
344
221022
    for (i = 0; i < 2; i++) {
345


147348
        UPDATE_TABLE(motion_val_buf[i]);
346


147348
        UPDATE_TABLE(ref_index_buf[i]);
347
    }
348
349
73674
    dst->mb_var        = src->mb_var;
350
73674
    dst->mc_mb_var     = src->mc_mb_var;
351
73674
    dst->mb_mean       = src->mb_mean;
352
73674
    dst->mbskip_table  = src->mbskip_table;
353
73674
    dst->qscale_table  = src->qscale_table;
354
73674
    dst->mb_type       = src->mb_type;
355
221022
    for (i = 0; i < 2; i++) {
356
147348
        dst->motion_val[i] = src->motion_val[i];
357
147348
        dst->ref_index[i]  = src->ref_index[i];
358
    }
359
360
73674
    dst->alloc_mb_width  = src->alloc_mb_width;
361
73674
    dst->alloc_mb_height = src->alloc_mb_height;
362
363
73674
    return 0;
364
}
365
366
73674
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
367
{
368
    int ret;
369
370
73674
    av_assert0(!dst->f->buf[0]);
371
73674
    av_assert0(src->f->buf[0]);
372
373
73674
    src->tf.f = src->f;
374
73674
    dst->tf.f = dst->f;
375
73674
    ret = ff_thread_ref_frame(&dst->tf, &src->tf);
376
73674
    if (ret < 0)
377
        goto fail;
378
379
73674
    ret = ff_update_picture_tables(dst, src);
380
73674
    if (ret < 0)
381
        goto fail;
382
383
73674
    if (src->hwaccel_picture_private) {
384
        dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
385
        if (!dst->hwaccel_priv_buf) {
386
            ret = AVERROR(ENOMEM);
387
            goto fail;
388
        }
389
        dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
390
    }
391
392
73674
    dst->field_picture           = src->field_picture;
393
73674
    dst->mb_var_sum              = src->mb_var_sum;
394
73674
    dst->mc_mb_var_sum           = src->mc_mb_var_sum;
395
73674
    dst->b_frame_score           = src->b_frame_score;
396
73674
    dst->needs_realloc           = src->needs_realloc;
397
73674
    dst->reference               = src->reference;
398
73674
    dst->shared                  = src->shared;
399
400
73674
    memcpy(dst->encoding_error, src->encoding_error,
401
           sizeof(dst->encoding_error));
402
403
73674
    return 0;
404
fail:
405
    ff_mpeg_unref_picture(avctx, dst);
406
    return ret;
407
}
408
409
41068
static inline int pic_is_unused(Picture *pic)
410
{
411
41068
    if (!pic->f->buf[0])
412
18819
        return 1;
413

22249
    if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
414
20
        return 1;
415
22229
    return 0;
416
}
417
418
19488
static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
419
{
420
    int i;
421
422
19488
    if (shared) {
423
852
        for (i = 0; i < MAX_PICTURE_COUNT; i++) {
424
852
            if (!picture[i].f->buf[0])
425
649
                return i;
426
        }
427
    } else {
428
41068
        for (i = 0; i < MAX_PICTURE_COUNT; i++) {
429
41068
            if (pic_is_unused(&picture[i]))
430
18839
                return i;
431
        }
432
    }
433
434
    av_log(avctx, AV_LOG_FATAL,
435
           "Internal error, picture buffer overflow\n");
436
    /* We could return -1, but the codec would crash trying to draw into a
437
     * non-existing frame anyway. This is safer than waiting for a random crash.
438
     * Also the return of this is never useful, an encoder must only allocate
439
     * as much as allowed in the specification. This has no relationship to how
440
     * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
441
     * enough for such valid streams).
442
     * Plus, a decoder has to check stream validity and remove frames if too
443
     * many reference frames are around. Waiting for "OOM" is not correct at
444
     * all. Similarly, missing reference frames have to be replaced by
445
     * interpolated/MC frames, anything else is a bug in the codec ...
446
     */
447
    abort();
448
    return -1;
449
}
450
451
19488
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
452
{
453
19488
    int ret = find_unused_picture(avctx, picture, shared);
454
455

19488
    if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
456
19488
        if (picture[ret].needs_realloc) {
457
20
            picture[ret].needs_realloc = 0;
458
20
            ff_free_picture_tables(&picture[ret]);
459
20
            ff_mpeg_unref_picture(avctx, &picture[ret]);
460
        }
461
    }
462
19488
    return ret;
463
}
464
465
31386
void ff_free_picture_tables(Picture *pic)
466
{
467
    int i;
468
469
31386
    pic->alloc_mb_width  =
470
31386
    pic->alloc_mb_height = 0;
471
472
31386
    av_buffer_unref(&pic->mb_var_buf);
473
31386
    av_buffer_unref(&pic->mc_mb_var_buf);
474
31386
    av_buffer_unref(&pic->mb_mean_buf);
475
31386
    av_buffer_unref(&pic->mbskip_table_buf);
476
31386
    av_buffer_unref(&pic->qscale_table_buf);
477
31386
    av_buffer_unref(&pic->mb_type_buf);
478
479
94158
    for (i = 0; i < 2; i++) {
480
62772
        av_buffer_unref(&pic->motion_val_buf[i]);
481
62772
        av_buffer_unref(&pic->ref_index_buf[i]);
482
    }
483
31386
}