GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mpegutils.c Lines: 92 156 59.0 %
Date: 2019-11-22 03:34:36 Branches: 59 138 42.8 %

Line Branch Exec Source
1
/*
2
 * Mpeg video formats-related defines and utility 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/common.h"
24
#include "libavutil/frame.h"
25
#include "libavutil/pixdesc.h"
26
#include "libavutil/motion_vector.h"
27
#include "libavutil/avassert.h"
28
29
#include "avcodec.h"
30
#include "mpegutils.h"
31
32
1014
static int add_mb(AVMotionVector *mb, uint32_t mb_type,
33
                  int dst_x, int dst_y,
34
                  int motion_x, int motion_y, int motion_scale,
35
                  int direction)
36
{
37

1014
    mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
38

1014
    mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
39
1014
    mb->motion_x = motion_x;
40
1014
    mb->motion_y = motion_y;
41
1014
    mb->motion_scale = motion_scale;
42
1014
    mb->dst_x = dst_x;
43
1014
    mb->dst_y = dst_y;
44
1014
    mb->src_x = dst_x + motion_x / motion_scale;
45
1014
    mb->src_y = dst_y + motion_y / motion_scale;
46
1014
    mb->source = direction ? 1 : -1;
47
1014
    mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
48
1014
    return 1;
49
}
50
51
189305
void ff_draw_horiz_band(AVCodecContext *avctx,
52
                        AVFrame *cur, AVFrame *last,
53
                        int y, int h, int picture_structure,
54
                        int first_field, int low_delay)
55
{
56
189305
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
57
189305
    int vshift = desc->log2_chroma_h;
58
189305
    const int field_pic = picture_structure != PICT_FRAME;
59
189305
    if (field_pic) {
60
15272
        h <<= 1;
61
15272
        y <<= 1;
62
    }
63
64
189305
    h = FFMIN(h, avctx->height - y);
65
66

189305
    if (field_pic && first_field &&
67
7650
        !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
68
7650
        return;
69
70
181655
    if (avctx->draw_horiz_band) {
71
        AVFrame *src;
72
        int offset[AV_NUM_DATA_POINTERS];
73
        int i;
74
75

3350
        if (cur->pict_type == AV_PICTURE_TYPE_B || low_delay ||
76
           (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
77
3350
            src = cur;
78
        else if (last)
79
            src = last;
80
        else
81
            return;
82
83

3350
        if (cur->pict_type == AV_PICTURE_TYPE_B &&
84
            picture_structure == PICT_FRAME &&
85
            avctx->codec_id != AV_CODEC_ID_SVQ3) {
86
            for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
87
                offset[i] = 0;
88
        } else {
89
3350
            offset[0]= y * src->linesize[0];
90
3350
            offset[1]=
91
3350
            offset[2]= (y >> vshift) * src->linesize[1];
92
20100
            for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
93
16750
                offset[i] = 0;
94
        }
95
96
3350
        emms_c();
97
98
3350
        avctx->draw_horiz_band(avctx, src, offset,
99
                               y, picture_structure, h);
100
    }
101
}
102
103
32796
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
104
                         uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
105
                         int *low_delay,
106
                         int mb_width, int mb_height, int mb_stride, int quarter_sample)
107
{
108

32796
    if ((avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) && mbtype_table && motion_val[0]) {
109
60
        const int shift = 1 + quarter_sample;
110
60
        const int scale = 1 << shift;
111

60
        const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
112
60
        const int mv_stride      = (mb_width << mv_sample_log2) +
113
60
                                   (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
114
60
        int mb_x, mb_y, mbcount = 0;
115
116
        /* size is width * height * 2 * 4 where 2 is for directions and 4 is
117
         * for the maximum number of MB (4 MB in case of IS_8x8) */
118
60
        AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
119
60
        if (!mvs)
120
            return;
121
122
1260
        for (mb_y = 0; mb_y < mb_height; mb_y++) {
123
44400
            for (mb_x = 0; mb_x < mb_width; mb_x++) {
124
43200
                int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
125
129600
                for (direction = 0; direction < 2; direction++) {
126
86400
                    if (!USES_LIST(mb_type, direction))
127
85527
                        continue;
128
873
                    if (IS_8X8(mb_type)) {
129
160
                        for (i = 0; i < 4; i++) {
130
128
                            int sx = mb_x * 16 + 4 + 8 * (i & 1);
131
128
                            int sy = mb_y * 16 + 4 + 8 * (i >> 1);
132
128
                            int xy = (mb_x * 2 + (i & 1) +
133
128
                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
134
128
                            int mx = motion_val[direction][xy][0];
135
128
                            int my = motion_val[direction][xy][1];
136
128
                            mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
137
                        }
138
841
                    } else if (IS_16X8(mb_type)) {
139
90
                        for (i = 0; i < 2; i++) {
140
60
                            int sx = mb_x * 16 + 8;
141
60
                            int sy = mb_y * 16 + 4 + 8 * i;
142
60
                            int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
143
60
                            int mx = motion_val[direction][xy][0];
144
60
                            int my = motion_val[direction][xy][1];
145
146
60
                            if (IS_INTERLACED(mb_type))
147
                                my *= 2;
148
149
60
                            mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
150
                        }
151
811
                    } else if (IS_8X16(mb_type)) {
152
45
                        for (i = 0; i < 2; i++) {
153
30
                            int sx = mb_x * 16 + 4 + 8 * i;
154
30
                            int sy = mb_y * 16 + 8;
155
30
                            int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
156
30
                            int mx = motion_val[direction][xy][0];
157
30
                            int my = motion_val[direction][xy][1];
158
159
30
                            if (IS_INTERLACED(mb_type))
160
                                my *= 2;
161
162
30
                            mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
163
                        }
164
                    } else {
165
796
                          int sx = mb_x * 16 + 8;
166
796
                          int sy = mb_y * 16 + 8;
167
796
                          int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
168
796
                          int mx = motion_val[direction][xy][0];
169
796
                          int my = motion_val[direction][xy][1];
170
796
                          mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
171
                    }
172
                }
173
            }
174
        }
175
176
60
        if (mbcount) {
177
            AVFrameSideData *sd;
178
179
27
            av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
180
27
            sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
181
27
            if (!sd) {
182
                av_freep(&mvs);
183
                return;
184
            }
185
27
            memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
186
        }
187
188
60
        av_freep(&mvs);
189
    }
190
191
    /* TODO: export all the following to make them accessible for users (and filters) */
192

32796
    if (avctx->hwaccel || !mbtype_table)
193
        return;
194
195
196
32796
    if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
197
        int x,y;
198
199
        av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
200
               av_get_picture_type_char(pict->pict_type));
201
        for (y = 0; y < mb_height; y++) {
202
            for (x = 0; x < mb_width; x++) {
203
                if (avctx->debug & FF_DEBUG_SKIP) {
204
                    int count = mbskip_table ? mbskip_table[x + y * mb_stride] : 0;
205
                    if (count > 9)
206
                        count = 9;
207
                    av_log(avctx, AV_LOG_DEBUG, "%1d", count);
208
                }
209
                if (avctx->debug & FF_DEBUG_QP) {
210
                    av_log(avctx, AV_LOG_DEBUG, "%2d",
211
                           qscale_table[x + y * mb_stride]);
212
                }
213
                if (avctx->debug & FF_DEBUG_MB_TYPE) {
214
                    int mb_type = mbtype_table[x + y * mb_stride];
215
                    // Type & MV direction
216
                    if (IS_PCM(mb_type))
217
                        av_log(avctx, AV_LOG_DEBUG, "P");
218
                    else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
219
                        av_log(avctx, AV_LOG_DEBUG, "A");
220
                    else if (IS_INTRA4x4(mb_type))
221
                        av_log(avctx, AV_LOG_DEBUG, "i");
222
                    else if (IS_INTRA16x16(mb_type))
223
                        av_log(avctx, AV_LOG_DEBUG, "I");
224
                    else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
225
                        av_log(avctx, AV_LOG_DEBUG, "d");
226
                    else if (IS_DIRECT(mb_type))
227
                        av_log(avctx, AV_LOG_DEBUG, "D");
228
                    else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
229
                        av_log(avctx, AV_LOG_DEBUG, "g");
230
                    else if (IS_GMC(mb_type))
231
                        av_log(avctx, AV_LOG_DEBUG, "G");
232
                    else if (IS_SKIP(mb_type))
233
                        av_log(avctx, AV_LOG_DEBUG, "S");
234
                    else if (!USES_LIST(mb_type, 1))
235
                        av_log(avctx, AV_LOG_DEBUG, ">");
236
                    else if (!USES_LIST(mb_type, 0))
237
                        av_log(avctx, AV_LOG_DEBUG, "<");
238
                    else {
239
                        av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
240
                        av_log(avctx, AV_LOG_DEBUG, "X");
241
                    }
242
243
                    // segmentation
244
                    if (IS_8X8(mb_type))
245
                        av_log(avctx, AV_LOG_DEBUG, "+");
246
                    else if (IS_16X8(mb_type))
247
                        av_log(avctx, AV_LOG_DEBUG, "-");
248
                    else if (IS_8X16(mb_type))
249
                        av_log(avctx, AV_LOG_DEBUG, "|");
250
                    else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
251
                        av_log(avctx, AV_LOG_DEBUG, " ");
252
                    else
253
                        av_log(avctx, AV_LOG_DEBUG, "?");
254
255
256
                    if (IS_INTERLACED(mb_type))
257
                        av_log(avctx, AV_LOG_DEBUG, "=");
258
                    else
259
                        av_log(avctx, AV_LOG_DEBUG, " ");
260
                }
261
            }
262
            av_log(avctx, AV_LOG_DEBUG, "\n");
263
        }
264
    }
265
266
#if FF_API_DEBUG_MV
267
    if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
268
        (avctx->debug_mv)) {
269
        int mb_y;
270
        int i, ret;
271
        int h_chroma_shift, v_chroma_shift, block_height;
272
        const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
273
        const int mv_stride      = (mb_width << mv_sample_log2) +
274
                                   (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
275
276
        if (low_delay)
277
            *low_delay = 0; // needed to see the vectors without trashing the buffers
278
279
        ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
280
        if (ret)
281
            return ret;
282
283
        av_frame_make_writable(pict);
284
285
        pict->opaque = NULL;
286
        block_height = 16 >> v_chroma_shift;
287
288
        for (mb_y = 0; mb_y < mb_height; mb_y++) {
289
            int mb_x;
290
            for (mb_x = 0; mb_x < mb_width; mb_x++) {
291
                const int mb_index = mb_x + mb_y * mb_stride;
292
                if ((avctx->debug & FF_DEBUG_VIS_QP)) {
293
                    uint64_t c = (qscale_table[mb_index] * 128 / 31) *
294
                                 0x0101010101010101ULL;
295
                    int y;
296
                    for (y = 0; y < block_height; y++) {
297
                        *(uint64_t *)(pict->data[1] + 8 * mb_x +
298
                                      (block_height * mb_y + y) *
299
                                      pict->linesize[1]) = c;
300
                        *(uint64_t *)(pict->data[2] + 8 * mb_x +
301
                                      (block_height * mb_y + y) *
302
                                      pict->linesize[2]) = c;
303
                    }
304
                }
305
                if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
306
                    motion_val[0]) {
307
                    int mb_type = mbtype_table[mb_index];
308
                    uint64_t u,v;
309
                    int y;
310
#define COLOR(theta, r) \
311
    u = (int)(128 + r * cos(theta * M_PI / 180)); \
312
    v = (int)(128 + r * sin(theta * M_PI / 180));
313
314
315
                    u = v = 128;
316
                    if (IS_PCM(mb_type)) {
317
                        COLOR(120, 48)
318
                    } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
319
                               IS_INTRA16x16(mb_type)) {
320
                        COLOR(30, 48)
321
                    } else if (IS_INTRA4x4(mb_type)) {
322
                        COLOR(90, 48)
323
                    } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
324
                        // COLOR(120, 48)
325
                    } else if (IS_DIRECT(mb_type)) {
326
                        COLOR(150, 48)
327
                    } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
328
                        COLOR(170, 48)
329
                    } else if (IS_GMC(mb_type)) {
330
                        COLOR(190, 48)
331
                    } else if (IS_SKIP(mb_type)) {
332
                        // COLOR(180, 48)
333
                    } else if (!USES_LIST(mb_type, 1)) {
334
                        COLOR(240, 48)
335
                    } else if (!USES_LIST(mb_type, 0)) {
336
                        COLOR(0, 48)
337
                    } else {
338
                        av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
339
                        COLOR(300,48)
340
                    }
341
342
                    u *= 0x0101010101010101ULL;
343
                    v *= 0x0101010101010101ULL;
344
                    for (y = 0; y < block_height; y++) {
345
                        *(uint64_t *)(pict->data[1] + 8 * mb_x +
346
                                      (block_height * mb_y + y) * pict->linesize[1]) = u;
347
                        *(uint64_t *)(pict->data[2] + 8 * mb_x +
348
                                      (block_height * mb_y + y) * pict->linesize[2]) = v;
349
                    }
350
351
                    // segmentation
352
                    if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
353
                        *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
354
                                      (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
355
                        *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
356
                                      (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
357
                    }
358
                    if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
359
                        for (y = 0; y < 16; y++)
360
                            pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
361
                                          pict->linesize[0]] ^= 0x80;
362
                    }
363
                    if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
364
                        int dm = 1 << (mv_sample_log2 - 2);
365
                        for (i = 0; i < 4; i++) {
366
                            int sx = mb_x * 16 + 8 * (i & 1);
367
                            int sy = mb_y * 16 + 8 * (i >> 1);
368
                            int xy = (mb_x * 2 + (i & 1) +
369
                                     (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
370
                            // FIXME bidir
371
                            int32_t *mv = (int32_t *) &motion_val[0][xy];
372
                            if (mv[0] != mv[dm] ||
373
                                mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
374
                                for (y = 0; y < 8; y++)
375
                                    pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
376
                            if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
377
                                *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
378
                                              pict->linesize[0]) ^= 0x8080808080808080ULL;
379
                        }
380
                    }
381
382
                    if (IS_INTERLACED(mb_type) &&
383
                        avctx->codec->id == AV_CODEC_ID_H264) {
384
                        // hmm
385
                    }
386
                }
387
                if (mbskip_table)
388
                    mbskip_table[mb_index] = 0;
389
            }
390
        }
391
    }
392
#endif
393
}