GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/v210dec.c Lines: 86 99 86.9 %
Date: 2020-10-23 17:01:47 Branches: 20 40 50.0 %

Line Branch Exec Source
1
/*
2
 * V210 decoder
3
 *
4
 * Copyright (C) 2009 Michael Niedermayer <michaelni@gmx.at>
5
 * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
6
 *
7
 * This file is part of FFmpeg.
8
 *
9
 * FFmpeg is free software; you can redistribute it and/or
10
 * modify it under the terms of the GNU Lesser General Public
11
 * License as published by the Free Software Foundation; either
12
 * version 2.1 of the License, or (at your option) any later version.
13
 *
14
 * FFmpeg is distributed in the hope that it will be useful,
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
 * Lesser General Public License for more details.
18
 *
19
 * You should have received a copy of the GNU Lesser General Public
20
 * License along with FFmpeg; if not, write to the Free Software
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
 */
23
24
#include "avcodec.h"
25
#include "internal.h"
26
#include "v210dec.h"
27
#include "libavutil/bswap.h"
28
#include "libavutil/internal.h"
29
#include "libavutil/mem.h"
30
#include "libavutil/intreadwrite.h"
31
#include "thread.h"
32
33
#define READ_PIXELS(a, b, c)         \
34
    do {                             \
35
        val  = av_le2ne32(*src++);   \
36
        *a++ =  val & 0x3FF;         \
37
        *b++ = (val >> 10) & 0x3FF;  \
38
        *c++ = (val >> 20) & 0x3FF;  \
39
    } while (0)
40
41
typedef struct ThreadData {
42
    AVFrame *frame;
43
    uint8_t *buf;
44
    int stride;
45
} ThreadData;
46
47
90523
static void v210_planar_unpack_c(const uint32_t *src, uint16_t *y, uint16_t *u, uint16_t *v, int width)
48
{
49
    uint32_t val;
50
    int i;
51
52
5268473
    for( i = 0; i < width-5; i += 6 ){
53
5177950
        READ_PIXELS(u, y, v);
54
5177950
        READ_PIXELS(y, u, y);
55
5177950
        READ_PIXELS(v, y, u);
56
5177950
        READ_PIXELS(y, v, y);
57
    }
58
90523
}
59
60
40
av_cold void ff_v210dec_init(V210DecContext *s)
61
{
62
40
    s->unpack_frame = v210_planar_unpack_c;
63
    if (ARCH_X86)
64
40
        ff_v210_x86_init(s);
65
40
}
66
67
18
static av_cold int decode_init(AVCodecContext *avctx)
68
{
69
18
    V210DecContext *s = avctx->priv_data;
70
71
18
    avctx->pix_fmt             = AV_PIX_FMT_YUV422P10;
72
18
    avctx->bits_per_raw_sample = 10;
73
74
18
    s->thread_count  = av_clip(avctx->thread_count, 1, avctx->height/4);
75
18
    s->aligned_input = 0;
76
18
    ff_v210dec_init(s);
77
78
18
    return 0;
79
}
80
81
401
static int v210_decode_slice(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
82
{
83
401
    V210DecContext *s = avctx->priv_data;
84
    int h, w;
85
401
    ThreadData *td = arg;
86
401
    AVFrame *frame = td->frame;
87
401
    int stride = td->stride;
88
401
    int slice_start = (avctx->height *  jobnr) / s->thread_count;
89
401
    int slice_end = (avctx->height * (jobnr+1)) / s->thread_count;
90
401
    uint8_t *psrc = td->buf + stride * slice_start;
91
    uint16_t *y, *u, *v;
92
93
401
    y = (uint16_t*)frame->data[0] + slice_start * frame->linesize[0] / 2;
94
401
    u = (uint16_t*)frame->data[1] + slice_start * frame->linesize[1] / 2;
95
401
    v = (uint16_t*)frame->data[2] + slice_start * frame->linesize[2] / 2;
96
90921
    for (h = slice_start; h < slice_end; h++) {
97
90520
        const uint32_t *src = (const uint32_t*)psrc;
98
        uint32_t val;
99
100
90520
        w = (avctx->width / 12) * 12;
101
90520
        s->unpack_frame(src, y, u, v, w);
102
103
90520
        y += w;
104
90520
        u += w >> 1;
105
90520
        v += w >> 1;
106
90520
        src += (w << 1) / 3;
107
108
90520
        if (w < avctx->width - 5) {
109
4120
            READ_PIXELS(u, y, v);
110
4120
            READ_PIXELS(y, u, y);
111
4120
            READ_PIXELS(v, y, u);
112
4120
            READ_PIXELS(y, v, y);
113
4120
            w += 6;
114
        }
115
116
90520
        if (w < avctx->width - 1) {
117
90520
            READ_PIXELS(u, y, v);
118
119
90520
            val  = av_le2ne32(*src++);
120
90520
            *y++ =  val & 0x3FF;
121
90520
            if (w < avctx->width - 3) {
122
89800
                *u++ = (val >> 10) & 0x3FF;
123
89800
                *y++ = (val >> 20) & 0x3FF;
124
125
89800
                val  = av_le2ne32(*src++);
126
89800
                *v++ =  val & 0x3FF;
127
89800
                *y++ = (val >> 10) & 0x3FF;
128
            }
129
        }
130
131
90520
        psrc += stride;
132
90520
        y += frame->linesize[0] / 2 - avctx->width + (avctx->width & 1);
133
90520
        u += frame->linesize[1] / 2 - avctx->width / 2;
134
90520
        v += frame->linesize[2] / 2 - avctx->width / 2;
135
    }
136
137
401
    return 0;
138
}
139
140
402
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
141
                        AVPacket *avpkt)
142
{
143
402
    V210DecContext *s = avctx->priv_data;
144
    ThreadData td;
145
    int ret, stride, aligned_input;
146
402
    ThreadFrame frame = { .f = data };
147
402
    AVFrame *pic = data;
148
402
    const uint8_t *psrc = avpkt->data;
149
150
402
    if (s->custom_stride )
151
        stride = s->custom_stride;
152
    else {
153
402
        int aligned_width = ((avctx->width + 47) / 48) * 48;
154
402
        stride = aligned_width * 8 / 3;
155
    }
156
157
402
    if (avpkt->size < stride * avctx->height) {
158
1
        if ((((avctx->width + 23) / 24) * 24 * 8) / 3 * avctx->height == avpkt->size) {
159
            stride = avpkt->size / avctx->height;
160
            if (!s->stride_warning_shown)
161
                av_log(avctx, AV_LOG_WARNING, "Broken v210 with too small padding (64 byte) detected\n");
162
            s->stride_warning_shown = 1;
163
        } else {
164
1
            av_log(avctx, AV_LOG_ERROR, "packet too small\n");
165
1
            return AVERROR_INVALIDDATA;
166
        }
167
    }
168
401
    td.stride = stride;
169
401
    if (   avctx->codec_tag == MKTAG('C', '2', '1', '0')
170
        && avpkt->size > 64
171
        && AV_RN32(psrc) == AV_RN32("INFO")
172
        && avpkt->size - 64 >= stride * avctx->height)
173
        psrc += 64;
174
175

401
    aligned_input = !((uintptr_t)psrc & 0x1f) && !(stride & 0x1f);
176
401
    if (aligned_input != s->aligned_input) {
177
9
        s->aligned_input = aligned_input;
178
9
        ff_v210dec_init(s);
179
    }
180
181
401
    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
182
        return ret;
183
184
401
    pic->pict_type = AV_PICTURE_TYPE_I;
185
401
    pic->key_frame = 1;
186
187
401
    td.buf = (uint8_t*)psrc;
188
401
    td.frame = pic;
189
401
    avctx->execute2(avctx, v210_decode_slice, &td, NULL, s->thread_count);
190
191
401
    if (avctx->field_order > AV_FIELD_PROGRESSIVE) {
192
        /* we have interlaced material flagged in container */
193
        pic->interlaced_frame = 1;
194
        if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
195
            pic->top_field_first = 1;
196
    }
197
198
401
    *got_frame      = 1;
199
200
401
    return avpkt->size;
201
}
202
203
#define V210DEC_FLAGS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
204
static const AVOption v210dec_options[] = {
205
    {"custom_stride", "Custom V210 stride", offsetof(V210DecContext, custom_stride), AV_OPT_TYPE_INT,
206
     {.i64 = 0}, INT_MIN, INT_MAX, V210DEC_FLAGS},
207
    {NULL}
208
};
209
210
static const AVClass v210dec_class = {
211
    .class_name = "V210 Decoder",
212
    .item_name  = av_default_item_name,
213
    .option     = v210dec_options,
214
    .version    = LIBAVUTIL_VERSION_INT,
215
};
216
217
AVCodec ff_v210_decoder = {
218
    .name           = "v210",
219
    .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
220
    .type           = AVMEDIA_TYPE_VIDEO,
221
    .id             = AV_CODEC_ID_V210,
222
    .priv_data_size = sizeof(V210DecContext),
223
    .init           = decode_init,
224
    .decode         = decode_frame,
225
    .capabilities   = AV_CODEC_CAP_DR1 |
226
                      AV_CODEC_CAP_SLICE_THREADS |
227
                      AV_CODEC_CAP_FRAME_THREADS,
228
    .priv_class     = &v210dec_class,
229
};