GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/vaapi_mjpeg.c Lines: 0 64 0.0 %
Date: 2020-08-14 10:39:37 Branches: 0 26 0.0 %

Line Branch Exec Source
1
/*
2
 * This file is part of FFmpeg.
3
 *
4
 * FFmpeg is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * FFmpeg is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with FFmpeg; if not, write to the Free Software
16
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
 */
18
19
#include <va/va.h>
20
#include <va/va_dec_jpeg.h>
21
22
#include "hwconfig.h"
23
#include "vaapi_decode.h"
24
#include "mjpegdec.h"
25
26
static int vaapi_mjpeg_start_frame(AVCodecContext          *avctx,
27
                                   av_unused const uint8_t *buffer,
28
                                   av_unused uint32_t       size)
29
{
30
    const MJpegDecodeContext *s = avctx->priv_data;
31
    VAAPIDecodePicture *pic = s->hwaccel_picture_private;
32
    VAPictureParameterBufferJPEGBaseline pp;
33
    int err, i;
34
35
    pic->output_surface = ff_vaapi_get_surface_id(s->picture_ptr);
36
37
    pp = (VAPictureParameterBufferJPEGBaseline) {
38
        .picture_width  = avctx->width,
39
        .picture_height = avctx->height,
40
41
        .num_components = s->nb_components,
42
    };
43
44
    for (i = 0; i < s->nb_components; i++) {
45
        pp.components[i].component_id             = s->component_id[i];
46
        pp.components[i].h_sampling_factor        = s->h_count[i];
47
        pp.components[i].v_sampling_factor        = s->v_count[i];
48
        pp.components[i].quantiser_table_selector = s->quant_index[i];
49
    }
50
51
    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
52
                                            VAPictureParameterBufferType,
53
                                            &pp, sizeof(pp));
54
    if (err < 0)
55
        goto fail;
56
57
    return 0;
58
59
fail:
60
    ff_vaapi_decode_cancel(avctx, pic);
61
    return err;
62
}
63
64
static int vaapi_mjpeg_end_frame(AVCodecContext *avctx)
65
{
66
    const MJpegDecodeContext *s = avctx->priv_data;
67
    VAAPIDecodePicture *pic = s->hwaccel_picture_private;
68
69
    return ff_vaapi_decode_issue(avctx, pic);
70
}
71
72
static int vaapi_mjpeg_decode_slice(AVCodecContext *avctx,
73
                                    const uint8_t  *buffer,
74
                                    uint32_t        size)
75
{
76
    const MJpegDecodeContext *s = avctx->priv_data;
77
    VAAPIDecodePicture *pic = s->hwaccel_picture_private;
78
    VAHuffmanTableBufferJPEGBaseline huff;
79
    VAIQMatrixBufferJPEGBaseline quant;
80
    VASliceParameterBufferJPEGBaseline sp;
81
    int err, i, j;
82
83
    memset(&huff, 0, sizeof(huff));
84
    for (i = 0; i < 2; i++) {
85
        huff.load_huffman_table[i] = 1;
86
        for (j = 0; j < 16; j++)
87
            huff.huffman_table[i].num_dc_codes[j] = s->raw_huffman_lengths[0][i][j];
88
        for (j = 0; j < 12; j++)
89
            huff.huffman_table[i].dc_values[j] = s->raw_huffman_values[0][i][j];
90
        for (j = 0; j < 16; j++)
91
            huff.huffman_table[i].num_ac_codes[j] = s->raw_huffman_lengths[1][i][j];
92
        for (j = 0; j < 162; j++)
93
            huff.huffman_table[i].ac_values[j] = s->raw_huffman_values[1][i][j];
94
    }
95
96
    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
97
                                            VAHuffmanTableBufferType,
98
                                            &huff, sizeof(huff));
99
    if (err < 0)
100
        goto fail;
101
102
    memset(&quant, 0, sizeof(quant));
103
    for (i = 0; i < 4; i++) {
104
        quant.load_quantiser_table[i] = 1;
105
        for (j = 0; j < 64; j++)
106
            quant.quantiser_table[i][j] = s->quant_matrixes[i][j];
107
    }
108
109
    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
110
                                            VAIQMatrixBufferType,
111
                                            &quant, sizeof(quant));
112
    if (err < 0)
113
        goto fail;
114
115
    sp = (VASliceParameterBufferJPEGBaseline) {
116
        .slice_data_size   = size,
117
        .slice_data_offset = 0,
118
        .slice_data_flag   = VA_SLICE_DATA_FLAG_ALL,
119
120
        .slice_horizontal_position = 0,
121
        .slice_vertical_position   = 0,
122
123
        .restart_interval          = s->restart_interval,
124
        .num_mcus                  = s->mb_width * s->mb_height,
125
    };
126
127
    sp.num_components = s->nb_components;
128
    for (i = 0; i < s->nb_components; i++) {
129
        sp.components[i].component_selector = s->component_id[s->comp_index[i]];
130
        sp.components[i].dc_table_selector  = s->dc_index[i];
131
        sp.components[i].ac_table_selector  = s->ac_index[i];
132
    }
133
134
    err = ff_vaapi_decode_make_slice_buffer(avctx, pic, &sp, sizeof(sp), buffer, size);
135
    if (err)
136
        goto fail;
137
138
    return 0;
139
140
fail:
141
    ff_vaapi_decode_cancel(avctx, pic);
142
    return err;
143
}
144
145
const AVHWAccel ff_mjpeg_vaapi_hwaccel = {
146
    .name                 = "mjpeg_vaapi",
147
    .type                 = AVMEDIA_TYPE_VIDEO,
148
    .id                   = AV_CODEC_ID_MJPEG,
149
    .pix_fmt              = AV_PIX_FMT_VAAPI,
150
    .start_frame          = &vaapi_mjpeg_start_frame,
151
    .end_frame            = &vaapi_mjpeg_end_frame,
152
    .decode_slice         = &vaapi_mjpeg_decode_slice,
153
    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
154
    .init                 = &ff_vaapi_decode_init,
155
    .uninit               = &ff_vaapi_decode_uninit,
156
    .frame_params         = &ff_vaapi_common_frame_params,
157
    .priv_data_size       = sizeof(VAAPIDecodeContext),
158
    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
159
};