GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/bitpacked.c Lines: 0 55 0.0 %
Date: 2019-11-20 04:07:19 Branches: 0 32 0.0 %

Line Branch Exec Source
1
/*
2
 * Unpack bit-packed streams to formats supported by FFmpeg
3
 * Copyright (c) 2017 Savoir-faire Linux, Inc
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
/* Development sponsored by CBC/Radio-Canada */
23
24
/**
25
 * @file
26
 * Bitpacked
27
 */
28
29
#include "avcodec.h"
30
#include "internal.h"
31
#include "get_bits.h"
32
#include "libavutil/imgutils.h"
33
34
struct BitpackedContext {
35
    int (*decode)(AVCodecContext *avctx, AVFrame *frame,
36
                  AVPacket *pkt);
37
};
38
39
/* For this format, it's a simple passthrough */
40
static int bitpacked_decode_uyvy422(AVCodecContext *avctx, AVFrame *frame,
41
                                    AVPacket *avpkt)
42
{
43
    int ret;
44
45
    /* there is no need to copy as the data already match
46
     * a known pixel format */
47
    frame->buf[0] = av_buffer_ref(avpkt->buf);
48
    ret = av_image_fill_arrays(frame->data, frame->linesize, avpkt->data,
49
                               avctx->pix_fmt, avctx->width, avctx->height, 1);
50
    if (ret < 0) {
51
        av_buffer_unref(&frame->buf[0]);
52
        return ret;
53
    }
54
55
    return 0;
56
}
57
58
static int bitpacked_decode_yuv422p10(AVCodecContext *avctx, AVFrame *frame,
59
                                      AVPacket *avpkt)
60
{
61
    uint64_t frame_size = (uint64_t)avctx->width * (uint64_t)avctx->height * 20;
62
    uint64_t packet_size = (uint64_t)avpkt->size * 8;
63
    GetBitContext bc;
64
    uint16_t *y, *u, *v;
65
    int ret, i, j;
66
67
    ret = ff_get_buffer(avctx, frame, 0);
68
    if (ret < 0)
69
        return ret;
70
71
    if (frame_size > packet_size)
72
        return AVERROR_INVALIDDATA;
73
74
    if (avctx->width % 2)
75
        return AVERROR_PATCHWELCOME;
76
77
    ret = init_get_bits(&bc, avpkt->data, avctx->width * avctx->height * 20);
78
    if (ret)
79
        return ret;
80
81
    for (i = 0; i < avctx->height; i++) {
82
        y = (uint16_t*)(frame->data[0] + i * frame->linesize[0]);
83
        u = (uint16_t*)(frame->data[1] + i * frame->linesize[1]);
84
        v = (uint16_t*)(frame->data[2] + i * frame->linesize[2]);
85
86
        for (j = 0; j < avctx->width; j += 2) {
87
            *u++ = get_bits(&bc, 10);
88
            *y++ = get_bits(&bc, 10);
89
            *v++ = get_bits(&bc, 10);
90
            *y++ = get_bits(&bc, 10);
91
        }
92
    }
93
94
    return 0;
95
}
96
97
static av_cold int bitpacked_init_decoder(AVCodecContext *avctx)
98
{
99
    struct BitpackedContext *bc = avctx->priv_data;
100
101
    if (!avctx->codec_tag || !avctx->width || !avctx->height)
102
        return AVERROR_INVALIDDATA;
103
104
    if (avctx->codec_tag == MKTAG('U', 'Y', 'V', 'Y')) {
105
        if (avctx->bits_per_coded_sample == 16 &&
106
            avctx->pix_fmt == AV_PIX_FMT_UYVY422)
107
            bc->decode = bitpacked_decode_uyvy422;
108
        else if (avctx->bits_per_coded_sample == 20 &&
109
                 avctx->pix_fmt == AV_PIX_FMT_YUV422P10)
110
            bc->decode = bitpacked_decode_yuv422p10;
111
        else
112
            return AVERROR_INVALIDDATA;
113
    } else {
114
        return AVERROR_INVALIDDATA;
115
    }
116
117
    return 0;
118
}
119
120
static int bitpacked_decode(AVCodecContext *avctx, void *data, int *got_frame,
121
                            AVPacket *avpkt)
122
{
123
    struct BitpackedContext *bc = avctx->priv_data;
124
    int buf_size = avpkt->size;
125
    AVFrame *frame = data;
126
    int res;
127
128
    frame->pict_type = AV_PICTURE_TYPE_I;
129
    frame->key_frame = 1;
130
131
    res = bc->decode(avctx, frame, avpkt);
132
    if (res)
133
        return res;
134
135
    *got_frame = 1;
136
    return buf_size;
137
138
}
139
140
AVCodec ff_bitpacked_decoder = {
141
    .name   = "bitpacked",
142
    .long_name = NULL_IF_CONFIG_SMALL("Bitpacked"),
143
    .type = AVMEDIA_TYPE_VIDEO,
144
    .id = AV_CODEC_ID_BITPACKED,
145
    .priv_data_size        = sizeof(struct BitpackedContext),
146
    .init = bitpacked_init_decoder,
147
    .decode = bitpacked_decode,
148
    .capabilities = AV_CODEC_CAP_EXPERIMENTAL,
149
};