virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity
33d7f822f8
FFmpeg/libavcodec/vaapi_encode_mjpeg.c
Mark Thompson 478a4b7e6d vaapi_encode: Check packed header capabilities 
This improves behaviour with drivers which do not support packed
headers, such as AMD VCE on mesa/gallium.

(cherry picked from commit 892bbbcdc1)
2016-11-21 22:13:41 +00:00

431 lines
15 KiB
C
Raw Blame History

/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <va/va.h>
#include <va/va_enc_jpeg.h>
#include "libavutil/avassert.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/opt.h"
#include "libavutil/pixfmt.h"
#include "avcodec.h"
#include "internal.h"
#include "jpegtables.h"
#include "mjpeg.h"
#include "put_bits.h"
#include "vaapi_encode.h"
// Standard JPEG quantisation tables, in zigzag order.
static const unsigned char vaapi_encode_mjpeg_quant_luminance[64] = {
16, 11, 12, 14, 12, 10, 16, 14,
13, 14, 18, 17, 16, 19, 24, 40,
26, 24, 22, 22, 24, 49, 35, 37,
29, 40, 58, 51, 61, 60, 57, 51,
56, 55, 64, 72, 92, 78, 64, 68,
87, 69, 55, 56, 80, 109, 81, 87,
95, 98, 103, 104, 103, 62, 77, 113,
121, 112, 100, 120, 92, 101, 103, 99,
};
static const unsigned char vaapi_encode_mjpeg_quant_chrominance[64] = {
17, 18, 18, 24, 21, 24, 47, 26,
26, 47, 99, 66, 56, 66, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
};
typedef struct VAAPIEncodeMJPEGContext {
int quality;
int component_subsample_h[3];
int component_subsample_v[3];
VAQMatrixBufferJPEG quant_tables;
VAHuffmanTableBufferJPEGBaseline huffman_tables;
} VAAPIEncodeMJPEGContext;
static av_cold void vaapi_encode_mjpeg_copy_huffman(unsigned char *dst_lengths,
unsigned char *dst_values,
const unsigned char *src_lengths,
const unsigned char *src_values)
{
int i, mt;
++src_lengths;
mt = 0;
for (i = 0; i < 16; i++)
mt += (dst_lengths[i] = src_lengths[i]);
for (i = 0; i < mt; i++)
dst_values[i] = src_values[i];
}
static av_cold void vaapi_encode_mjpeg_init_tables(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeMJPEGContext *priv = ctx->priv_data;
VAQMatrixBufferJPEG *quant = &priv->quant_tables;
VAHuffmanTableBufferJPEGBaseline *huff = &priv->huffman_tables;
int i;
quant->load_lum_quantiser_matrix = 1;
quant->load_chroma_quantiser_matrix = 1;
for (i = 0; i < 64; i++) {
quant->lum_quantiser_matrix[i] =
vaapi_encode_mjpeg_quant_luminance[i];
quant->chroma_quantiser_matrix[i] =
vaapi_encode_mjpeg_quant_chrominance[i];
}
huff->load_huffman_table[0] = 1;
vaapi_encode_mjpeg_copy_huffman(huff->huffman_table[0].num_dc_codes,
huff->huffman_table[0].dc_values,
avpriv_mjpeg_bits_dc_luminance,
avpriv_mjpeg_val_dc);
vaapi_encode_mjpeg_copy_huffman(huff->huffman_table[0].num_ac_codes,
huff->huffman_table[0].ac_values,
avpriv_mjpeg_bits_ac_luminance,
avpriv_mjpeg_val_ac_luminance);
memset(huff->huffman_table[0].pad, 0, sizeof(huff->huffman_table[0].pad));
huff->load_huffman_table[1] = 1;
vaapi_encode_mjpeg_copy_huffman(huff->huffman_table[1].num_dc_codes,
huff->huffman_table[1].dc_values,
avpriv_mjpeg_bits_dc_chrominance,
avpriv_mjpeg_val_dc);
vaapi_encode_mjpeg_copy_huffman(huff->huffman_table[1].num_ac_codes,
huff->huffman_table[1].ac_values,
avpriv_mjpeg_bits_ac_chrominance,
avpriv_mjpeg_val_ac_chrominance);
memset(huff->huffman_table[1].pad, 0, sizeof(huff->huffman_table[1].pad));
}
static void vaapi_encode_mjpeg_write_marker(PutBitContext *pbc, int marker)
{
put_bits(pbc, 8, 0xff);
put_bits(pbc, 8, marker);
}
static int vaapi_encode_mjpeg_write_image_header(AVCodecContext *avctx,
VAAPIEncodePicture *pic,
VAAPIEncodeSlice *slice,
char *data, size_t *data_len)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAEncPictureParameterBufferJPEG *vpic = pic->codec_picture_params;
VAEncSliceParameterBufferJPEG *vslice = slice->codec_slice_params;
VAAPIEncodeMJPEGContext *priv = ctx->priv_data;
PutBitContext pbc;
int t, i, quant_scale;
init_put_bits(&pbc, data, *data_len);
vaapi_encode_mjpeg_write_marker(&pbc, SOI);
// Quantisation table coefficients are scaled for quality by the driver,
// so we also need to do it ourselves here so that headers match.
if (priv->quality < 50)
quant_scale = 5000 / priv->quality;
else
quant_scale = 200 - 2 * priv->quality;
for (t = 0; t < 2; t++) {
int q;
vaapi_encode_mjpeg_write_marker(&pbc, DQT);
put_bits(&pbc, 16, 3 + 64); // Lq
put_bits(&pbc, 4, 0); // Pq
put_bits(&pbc, 4, t); // Tq
for (i = 0; i < 64; i++) {
q = i[t ? priv->quant_tables.chroma_quantiser_matrix
: priv->quant_tables.lum_quantiser_matrix];
q = (q * quant_scale) / 100;
if (q < 1) q = 1;
if (q > 255) q = 255;
put_bits(&pbc, 8, q);
}
}
vaapi_encode_mjpeg_write_marker(&pbc, SOF0);
put_bits(&pbc, 16, 8 + 3 * vpic->num_components); // Lf
put_bits(&pbc, 8, vpic->sample_bit_depth); // P
put_bits(&pbc, 16, vpic->picture_height); // Y
put_bits(&pbc, 16, vpic->picture_width); // X
put_bits(&pbc, 8, vpic->num_components); // Nf
for (i = 0; i < vpic->num_components; i++) {
put_bits(&pbc, 8, vpic->component_id[i]); // Ci
put_bits(&pbc, 4, priv->component_subsample_h[i]); // Hi
put_bits(&pbc, 4, priv->component_subsample_v[i]); // Vi
put_bits(&pbc, 8, vpic->quantiser_table_selector[i]); // Tqi
}
for (t = 0; t < 4; t++) {
int mt;
unsigned char *lengths, *values;
vaapi_encode_mjpeg_write_marker(&pbc, DHT);
if ((t & 1) == 0) {
lengths = priv->huffman_tables.huffman_table[t / 2].num_dc_codes;
values = priv->huffman_tables.huffman_table[t / 2].dc_values;
} else {
lengths = priv->huffman_tables.huffman_table[t / 2].num_ac_codes;
values = priv->huffman_tables.huffman_table[t / 2].ac_values;
}
mt = 0;
for (i = 0; i < 16; i++)
mt += lengths[i];
put_bits(&pbc, 16, 2 + 17 + mt); // Lh
put_bits(&pbc, 4, t & 1); // Tc
put_bits(&pbc, 4, t / 2); // Th
for (i = 0; i < 16; i++)
put_bits(&pbc, 8, lengths[i]);
for (i = 0; i < mt; i++)
put_bits(&pbc, 8, values[i]);
}
vaapi_encode_mjpeg_write_marker(&pbc, SOS);
av_assert0(vpic->num_components == vslice->num_components);
put_bits(&pbc, 16, 6 + 2 * vslice->num_components); // Ls
put_bits(&pbc, 8, vslice->num_components); // Ns
for (i = 0; i < vslice->num_components; i++) {
put_bits(&pbc, 8, vslice->components[i].component_selector); // Csj
put_bits(&pbc, 4, vslice->components[i].dc_table_selector); // Tdj
put_bits(&pbc, 4, vslice->components[i].ac_table_selector); // Taj
}
put_bits(&pbc, 8, 0); // Ss
put_bits(&pbc, 8, 63); // Se
put_bits(&pbc, 4, 0); // Ah
put_bits(&pbc, 4, 0); // Al
*data_len = put_bits_count(&pbc);
flush_put_bits(&pbc);
return 0;
}
static int vaapi_encode_mjpeg_write_extra_buffer(AVCodecContext *avctx,
VAAPIEncodePicture *pic,
int index, int *type,
char *data, size_t *data_len)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeMJPEGContext *priv = ctx->priv_data;
if (index == 0) {
// Write quantisation tables.
if (*data_len < sizeof(priv->quant_tables))
return AVERROR(EINVAL);
*type = VAQMatrixBufferType;
memcpy(data, &priv->quant_tables,
*data_len = sizeof(priv->quant_tables));
} else if (index == 1) {
// Write huffman tables.
if (*data_len < sizeof(priv->huffman_tables))
return AVERROR(EINVAL);
*type = VAHuffmanTableBufferType;
memcpy(data, &priv->huffman_tables,
*data_len = sizeof(priv->huffman_tables));
} else {
return AVERROR_EOF;
}
return 0;
}
static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *pic)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAEncPictureParameterBufferJPEG *vpic = pic->codec_picture_params;
VAAPIEncodeMJPEGContext *priv = ctx->priv_data;
vpic->reconstructed_picture = pic->recon_surface;
vpic->coded_buf = pic->output_buffer;
vpic->picture_width = avctx->width;
vpic->picture_height = avctx->height;
vpic->pic_flags.bits.profile = 0;
vpic->pic_flags.bits.progressive = 0;
vpic->pic_flags.bits.huffman = 1;
vpic->pic_flags.bits.interleaved = 0;
vpic->pic_flags.bits.differential = 0;
vpic->sample_bit_depth = 8;
vpic->num_scan = 1;
vpic->num_components = 3;
vpic->component_id[0] = 1;
vpic->component_id[1] = 2;
vpic->component_id[2] = 3;
priv->component_subsample_h[0] = 2;
priv->component_subsample_v[0] = 2;
priv->component_subsample_h[1] = 1;
priv->component_subsample_v[1] = 1;
priv->component_subsample_h[2] = 1;
priv->component_subsample_v[2] = 1;
vpic->quantiser_table_selector[0] = 0;
vpic->quantiser_table_selector[1] = 1;
vpic->quantiser_table_selector[2] = 1;
vpic->quality = priv->quality;
pic->nb_slices = 1;
return 0;
}
static int vaapi_encode_mjpeg_init_slice_params(AVCodecContext *avctx,
VAAPIEncodePicture *pic,
VAAPIEncodeSlice *slice)
{
VAEncPictureParameterBufferJPEG *vpic = pic->codec_picture_params;
VAEncSliceParameterBufferJPEG *vslice = slice->codec_slice_params;
int i;
vslice->restart_interval = 0;
vslice->num_components = vpic->num_components;
for (i = 0; i < vslice->num_components; i++) {
vslice->components[i].component_selector = i + 1;
vslice->components[i].dc_table_selector = (i > 0);
vslice->components[i].ac_table_selector = (i > 0);
}
return 0;
}
static av_cold int vaapi_encode_mjpeg_configure(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeMJPEGContext *priv = ctx->priv_data;
priv->quality = avctx->global_quality;
if (priv->quality < 1 || priv->quality > 100) {
av_log(avctx, AV_LOG_ERROR, "Invalid quality value %d "
"(must be 1-100).\n", priv->quality);
return AVERROR(EINVAL);
}
// Hack: the implementation calls the JPEG image header (which we
// will use in the same way as a slice header) generic "raw data".
// Therefore, if after the packed header capability check we have
// PACKED_HEADER_RAW_DATA available, rewrite it as
// PACKED_HEADER_SLICE so that the header-writing code can do the
// right thing.
if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_RAW_DATA) {
ctx->va_packed_headers &= ~VA_ENC_PACKED_HEADER_RAW_DATA;
ctx->va_packed_headers |= VA_ENC_PACKED_HEADER_SLICE;
}
vaapi_encode_mjpeg_init_tables(avctx);
return 0;
}
static VAAPIEncodeType vaapi_encode_type_mjpeg = {
.priv_data_size = sizeof(VAAPIEncodeMJPEGContext),
.configure = &vaapi_encode_mjpeg_configure,
.picture_params_size = sizeof(VAEncPictureParameterBufferJPEG),
.init_picture_params = &vaapi_encode_mjpeg_init_picture_params,
.slice_params_size = sizeof(VAEncSliceParameterBufferJPEG),
.init_slice_params = &vaapi_encode_mjpeg_init_slice_params,
.slice_header_type = VAEncPackedHeaderRawData,
.write_slice_header = &vaapi_encode_mjpeg_write_image_header,
.write_extra_buffer = &vaapi_encode_mjpeg_write_extra_buffer,
};
static av_cold int vaapi_encode_mjpeg_init(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
ctx->codec = &vaapi_encode_type_mjpeg;
ctx->va_profile = VAProfileJPEGBaseline;
ctx->va_entrypoint = VAEntrypointEncPicture;
ctx->va_rt_format = VA_RT_FORMAT_YUV420;
ctx->va_rc_mode = VA_RC_CQP;
// The JPEG image header - see note above.
ctx->va_packed_headers =
VA_ENC_PACKED_HEADER_RAW_DATA;
ctx->surface_width = FFALIGN(avctx->width, 8);
ctx->surface_height = FFALIGN(avctx->height, 8);
return ff_vaapi_encode_init(avctx);
}
static const AVCodecDefault vaapi_encode_mjpeg_defaults[] = {
{ "global_quality", "80" },
{ NULL },
};
static const AVClass vaapi_encode_mjpeg_class = {
.class_name = "mjpeg_vaapi",
.item_name = av_default_item_name,
.version = LIBAVUTIL_VERSION_INT,
};
AVCodec ff_mjpeg_vaapi_encoder = {
.name = "mjpeg_vaapi",
.long_name = NULL_IF_CONFIG_SMALL("MJPEG (VAAPI)"),
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MJPEG,
.priv_data_size = sizeof(VAAPIEncodeContext),
.init = &vaapi_encode_mjpeg_init,
.encode2 = &ff_vaapi_encode2,
.close = &ff_vaapi_encode_close,
.priv_class = &vaapi_encode_mjpeg_class,
.defaults = vaapi_encode_mjpeg_defaults,
.pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_VAAPI,
AV_PIX_FMT_NONE,
},
};
Reference in New Issue View Git Blame Copy Permalink