GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/smvjpegdec.c Lines: 79 102 77.5 %
Date: 2020-08-13 15:06:06 Branches: 32 52 61.5 %

Line Branch Exec Source
1
/*
2
 * SMV JPEG decoder
3
 * Copyright (c) 2013 Ash Hughes
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
/**
23
 * @file
24
 * SMV JPEG decoder.
25
 */
26
27
// #define DEBUG
28
#include "avcodec.h"
29
#include "libavutil/opt.h"
30
#include "libavutil/imgutils.h"
31
#include "mjpegdec.h"
32
#include "internal.h"
33
34
typedef struct SMVJpegDecodeContext {
35
    MJpegDecodeContext jpg;
36
    AVFrame *picture[2]; /* pictures array */
37
    AVCodecContext* avctx;
38
    int frames_per_jpeg;
39
    int mjpeg_data_size;
40
} SMVJpegDecodeContext;
41
42
39
static inline void smv_img_pnt_plane(uint8_t      **dst, uint8_t *src,
43
                                     int src_linesize, int height, int nlines)
44
{
45

39
    if (!dst || !src)
46
        return;
47
39
    src += (nlines) * src_linesize * height;
48
39
    *dst = src;
49
}
50
51
13
static inline void smv_img_pnt(uint8_t *dst_data[4], uint8_t *src_data[4],
52
                               const int src_linesizes[4],
53
                               enum AVPixelFormat pix_fmt, int width, int height,
54
                               int nlines)
55
{
56
13
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
57
13
    int i, planes_nb = 0;
58
59
13
    if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
60
        return;
61
62
52
    for (i = 0; i < desc->nb_components; i++)
63
39
        planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
64
65
52
    for (i = 0; i < planes_nb; i++) {
66
39
        int h = height;
67

39
        if (i == 1 || i == 2) {
68
26
            h = AV_CEIL_RSHIFT(height, desc->log2_chroma_h);
69
        }
70
39
        smv_img_pnt_plane(&dst_data[i], src_data[i],
71
39
            src_linesizes[i], h, nlines);
72
    }
73
13
    if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
74
13
        desc->flags & FF_PSEUDOPAL)
75
        dst_data[1] = src_data[1];
76
}
77
78
2
static av_cold int smvjpeg_decode_end(AVCodecContext *avctx)
79
{
80
2
    SMVJpegDecodeContext *s = avctx->priv_data;
81
2
    MJpegDecodeContext *jpg = &s->jpg;
82
83
2
    jpg->picture_ptr = NULL;
84
2
    av_frame_free(&s->picture[0]);
85
2
    av_frame_free(&s->picture[1]);
86
2
    avcodec_free_context(&s->avctx);
87
2
    return 0;
88
}
89
90
2
static av_cold int smvjpeg_decode_init(AVCodecContext *avctx)
91
{
92
2
    SMVJpegDecodeContext *s = avctx->priv_data;
93
    AVCodec *codec;
94
2
    AVDictionary *thread_opt = NULL;
95
2
    int ret = 0, r;
96
97
2
    s->frames_per_jpeg = 0;
98
99
2
    s->picture[0] = av_frame_alloc();
100
2
    if (!s->picture[0])
101
        return AVERROR(ENOMEM);
102
103
2
    s->picture[1] = av_frame_alloc();
104
2
    if (!s->picture[1]) {
105
        av_frame_free(&s->picture[0]);
106
        return AVERROR(ENOMEM);
107
    }
108
109
2
    s->jpg.picture_ptr      = s->picture[0];
110
111
2
    if (avctx->extradata_size >= 4)
112
2
        s->frames_per_jpeg = AV_RL32(avctx->extradata);
113
114
2
    if (s->frames_per_jpeg <= 0) {
115
        av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n");
116
        ret = AVERROR_INVALIDDATA;
117
    }
118
119
2
    codec = avcodec_find_decoder(AV_CODEC_ID_MJPEG);
120
2
    if (!codec) {
121
        av_log(avctx, AV_LOG_ERROR, "MJPEG codec not found\n");
122
        smvjpeg_decode_end(avctx);
123
        return AVERROR_DECODER_NOT_FOUND;
124
    }
125
126
2
    s->avctx = avcodec_alloc_context3(codec);
127
128
2
    av_dict_set(&thread_opt, "threads", "1", 0);
129
2
    s->avctx->refcounted_frames = 1;
130
2
    s->avctx->flags = avctx->flags;
131
2
    s->avctx->idct_algo = avctx->idct_algo;
132
2
    if ((r = ff_codec_open2_recursive(s->avctx, codec, &thread_opt)) < 0) {
133
        av_log(avctx, AV_LOG_ERROR, "MJPEG codec failed to open\n");
134
        ret = r;
135
    }
136
2
    av_dict_free(&thread_opt);
137
138
2
    if (ret < 0)
139
        smvjpeg_decode_end(avctx);
140
2
    return ret;
141
}
142
143
13
static int smvjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
144
                            AVPacket *avpkt)
145
{
146
    const AVPixFmtDescriptor *desc;
147
13
    SMVJpegDecodeContext *s = avctx->priv_data;
148
13
    AVFrame* mjpeg_data = s->picture[0];
149
13
    int i, cur_frame = 0, ret = 0;
150
151
13
    cur_frame = avpkt->pts % s->frames_per_jpeg;
152
153
    /* cur_frame is later used to calculate the buffer offset, so it mustn't be negative */
154
13
    if (cur_frame < 0)
155
        cur_frame += s->frames_per_jpeg;
156
157
    /* Are we at the start of a block? */
158
13
    if (!cur_frame) {
159
3
        av_frame_unref(mjpeg_data);
160
3
        ret = avcodec_decode_video2(s->avctx, mjpeg_data, &s->mjpeg_data_size, avpkt);
161
3
        if (ret < 0) {
162
            s->mjpeg_data_size = 0;
163
            return ret;
164
        }
165
10
    } else if (!s->mjpeg_data_size)
166
        return AVERROR(EINVAL);
167
168
13
    desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
169
13
    av_assert0(desc);
170
171
13
    if (mjpeg_data->height % (s->frames_per_jpeg << desc->log2_chroma_h)) {
172
        av_log(avctx, AV_LOG_ERROR, "Invalid height\n");
173
        return AVERROR_INVALIDDATA;
174
    }
175
176
    /*use the last lot... */
177
13
    *data_size = s->mjpeg_data_size;
178
179
13
    avctx->pix_fmt = s->avctx->pix_fmt;
180
181
    /* We shouldn't get here if frames_per_jpeg <= 0 because this was rejected
182
       in init */
183
13
    ret = ff_set_dimensions(avctx, mjpeg_data->width, mjpeg_data->height / s->frames_per_jpeg);
184
13
    if (ret < 0) {
185
        av_log(s, AV_LOG_ERROR, "Failed to set dimensions\n");
186
        return ret;
187
    }
188
189
13
    if (*data_size) {
190
13
        s->picture[1]->extended_data = NULL;
191
13
        s->picture[1]->width         = avctx->width;
192
13
        s->picture[1]->height        = avctx->height;
193
13
        s->picture[1]->format        = avctx->pix_fmt;
194
13
        smv_img_pnt(s->picture[1]->data, mjpeg_data->data, mjpeg_data->linesize,
195
                    avctx->pix_fmt, avctx->width, avctx->height, cur_frame);
196
117
        for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
197
104
            s->picture[1]->linesize[i] = mjpeg_data->linesize[i];
198
199
13
        ret = av_frame_ref(data, s->picture[1]);
200
13
        if (ret < 0)
201
            return ret;
202
    }
203
204
13
    return avpkt->size;
205
}
206
207
static const AVClass smvjpegdec_class = {
208
    .class_name = "SMVJPEG decoder",
209
    .item_name  = av_default_item_name,
210
    .version    = LIBAVUTIL_VERSION_INT,
211
};
212
213
AVCodec ff_smvjpeg_decoder = {
214
    .name           = "smvjpeg",
215
    .long_name      = NULL_IF_CONFIG_SMALL("SMV JPEG"),
216
    .type           = AVMEDIA_TYPE_VIDEO,
217
    .id             = AV_CODEC_ID_SMVJPEG,
218
    .priv_data_size = sizeof(SMVJpegDecodeContext),
219
    .init           = smvjpeg_decode_init,
220
    .close          = smvjpeg_decode_end,
221
    .decode         = smvjpeg_decode_frame,
222
    .priv_class     = &smvjpegdec_class,
223
};