ffmpeg/libavcodec/bsf/evc_frame_merge.c

290 lines
9.0 KiB
C

/*
* Copyright (c) 2019 James Almer <jamrial@gmail.com>
*
* 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 "get_bits.h"
#include "bsf.h"
#include "bsf_internal.h"
#include "evc.h"
#include "evc_parse.h"
#include "evc_ps.h"
// Access unit data
typedef struct AccessUnitBuffer {
uint8_t *data; // the data buffer
size_t data_size; // size of data in bytes
unsigned capacity; // buffer capacity
} AccessUnitBuffer;
typedef struct EVCFMergeContext {
AVPacket *in, *buffer_pkt;
EVCParamSets ps;
EVCParserPoc poc;
AccessUnitBuffer au_buffer;
} EVCFMergeContext;
static int end_of_access_unit_found(const EVCParamSets *ps, const EVCParserSliceHeader *sh,
const EVCParserPoc *poc, enum EVCNALUnitType nalu_type)
{
EVCParserPPS *pps = ps->pps[sh->slice_pic_parameter_set_id];
EVCParserSPS *sps = ps->sps[pps->pps_seq_parameter_set_id];
av_assert0(sps && pps);
if (sps->profile_idc == 0) { // BASELINE profile
if (nalu_type == EVC_NOIDR_NUT || nalu_type == EVC_IDR_NUT)
return 1;
} else { // MAIN profile
if (nalu_type == EVC_NOIDR_NUT) {
if (poc->PicOrderCntVal != poc->prevPicOrderCntVal)
return 1;
} else if (nalu_type == EVC_IDR_NUT)
return 1;
}
return 0;
}
static void evc_frame_merge_flush(AVBSFContext *bsf)
{
EVCFMergeContext *ctx = bsf->priv_data;
ff_evc_ps_free(&ctx->ps);
av_packet_unref(ctx->in);
av_packet_unref(ctx->buffer_pkt);
ctx->au_buffer.data_size = 0;
}
static int parse_nal_unit(AVBSFContext *bsf, const uint8_t *buf, int buf_size)
{
EVCFMergeContext *ctx = bsf->priv_data;
GetBitContext gb;
enum EVCNALUnitType nalu_type;
int tid, err;
err = init_get_bits8(&gb, buf, buf_size);
if (err < 0)
return err;
// @see ISO_IEC_23094-1_2020, 7.4.2.2 NAL unit header semantic (Table 4 - NAL unit type codes and NAL unit type classes)
// @see enum EVCNALUnitType in evc.h
if (get_bits1(&gb)) {// forbidden_zero_bit
av_log(bsf, AV_LOG_ERROR, "Invalid NAL unit header\n");
return AVERROR_INVALIDDATA;
}
nalu_type = get_bits(&gb, 6) - 1;
if (nalu_type < EVC_NOIDR_NUT || nalu_type > EVC_UNSPEC_NUT62) {
av_log(bsf, AV_LOG_ERROR, "Invalid NAL unit type: (%d)\n", nalu_type);
return AVERROR_INVALIDDATA;
}
tid = get_bits(&gb, 3);
skip_bits(&gb, 5); // nuh_reserved_zero_5bits
skip_bits1(&gb); // nuh_extension_flag
switch (nalu_type) {
case EVC_SPS_NUT:
err = ff_evc_parse_sps(&gb, &ctx->ps);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "SPS parsing error\n");
return err;
}
break;
case EVC_PPS_NUT:
err = ff_evc_parse_pps(&gb, &ctx->ps);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "PPS parsing error\n");
return err;
}
break;
case EVC_IDR_NUT: // Coded slice of a IDR or non-IDR picture
case EVC_NOIDR_NUT: {
EVCParserSliceHeader sh;
err = ff_evc_parse_slice_header(&gb, &sh, &ctx->ps, nalu_type);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "Slice header parsing error\n");
return err;
}
// POC (picture order count of the current picture) derivation
// @see ISO/IEC 23094-1:2020(E) 8.3.1 Decoding process for picture order count
err = ff_evc_derive_poc(&ctx->ps, &sh, &ctx->poc, nalu_type, tid);
if (err < 0)
return err;
return end_of_access_unit_found(&ctx->ps, &sh, &ctx->poc, nalu_type);
break;
}
case EVC_SEI_NUT: // Supplemental Enhancement Information
case EVC_APS_NUT: // Adaptation parameter set
case EVC_FD_NUT: // Filler data
default:
break;
}
return 0;
}
static int evc_frame_merge_filter(AVBSFContext *bsf, AVPacket *out)
{
EVCFMergeContext *ctx = bsf->priv_data;
AVPacket *in = ctx->in, *buffer_pkt = ctx->buffer_pkt;
size_t data_size;
int au_end_found = 0, err;
while (!au_end_found) {
uint8_t *buffer;
uint32_t nalu_size;
if (!in->size) {
av_packet_unref(in);
err = ff_bsf_get_packet_ref(bsf, in);
if (err < 0) {
if (err == AVERROR_EOF && ctx->au_buffer.data_size > 0)
break;
return err;
}
/* Buffer packets with timestamps (there should be at most one per AU)
* or any packet if buffer_pkt is empty. The latter is needed to
* passthrough positions in case there are no timestamps like with
* the raw EVC demuxer. */
if (!buffer_pkt->data ||
in->pts != AV_NOPTS_VALUE && buffer_pkt->pts == AV_NOPTS_VALUE) {
err = av_packet_ref(buffer_pkt, in);
if (err < 0)
goto end;
}
}
// Buffer size is not enough for buffer to store NAL unit 4-bytes prefix (length)
if (in->size < EVC_NALU_LENGTH_PREFIX_SIZE)
return AVERROR_INVALIDDATA;
nalu_size = evc_read_nal_unit_length(in->data, EVC_NALU_LENGTH_PREFIX_SIZE, bsf);
if (!nalu_size || nalu_size > INT_MAX) {
av_log(bsf, AV_LOG_ERROR, "Invalid NAL unit size: (%u)\n", nalu_size);
err = AVERROR_INVALIDDATA;
goto end;
}
if (in->size < nalu_size + EVC_NALU_LENGTH_PREFIX_SIZE) {
err = AVERROR_INVALIDDATA;
goto end;
}
err = parse_nal_unit(bsf, in->data + EVC_NALU_LENGTH_PREFIX_SIZE, nalu_size);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "Parsing of NAL unit failed\n");
goto end;
}
au_end_found = err;
nalu_size += EVC_NALU_LENGTH_PREFIX_SIZE;
data_size = ctx->au_buffer.data_size + nalu_size;
if (data_size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
av_log(bsf, AV_LOG_ERROR, "Assembled packet is too big\n");
err = AVERROR(ERANGE);
goto end;
}
buffer = av_fast_realloc(ctx->au_buffer.data, &ctx->au_buffer.capacity,
data_size);
if (!buffer) {
av_freep(&ctx->au_buffer.data);
err = AVERROR_INVALIDDATA;
goto end;
}
ctx->au_buffer.data = buffer;
memcpy(ctx->au_buffer.data + ctx->au_buffer.data_size, in->data, nalu_size);
ctx->au_buffer.data_size = data_size;
in->data += nalu_size;
in->size -= nalu_size;
}
av_packet_unref(in);
data_size = ctx->au_buffer.data_size;
ctx->au_buffer.data_size = 0;
// drop the data in buffer_pkt, if any, but keep the props
av_buffer_unref(&buffer_pkt->buf);
err = av_buffer_realloc(&buffer_pkt->buf, data_size + AV_INPUT_BUFFER_PADDING_SIZE);
if (err < 0)
goto end;
buffer_pkt->data = buffer_pkt->buf->data;
buffer_pkt->size = data_size;
av_packet_move_ref(out, buffer_pkt);
memcpy(out->data, ctx->au_buffer.data, data_size);
memset(out->data + data_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
err = 0;
end:
if (err < 0) {
av_packet_unref(in);
av_packet_unref(buffer_pkt);
ctx->au_buffer.data_size = 0;
}
return err;
}
static int evc_frame_merge_init(AVBSFContext *bsf)
{
EVCFMergeContext *ctx = bsf->priv_data;
ctx->in = av_packet_alloc();
ctx->buffer_pkt = av_packet_alloc();
if (!ctx->in || !ctx->buffer_pkt)
return AVERROR(ENOMEM);
return 0;
}
static void evc_frame_merge_close(AVBSFContext *bsf)
{
EVCFMergeContext *ctx = bsf->priv_data;
av_packet_free(&ctx->in);
av_packet_free(&ctx->buffer_pkt);
ff_evc_ps_free(&ctx->ps);
ctx->au_buffer.capacity = 0;
av_freep(&ctx->au_buffer.data);
ctx->au_buffer.data_size = 0;
}
static const enum AVCodecID evc_frame_merge_codec_ids[] = {
AV_CODEC_ID_EVC, AV_CODEC_ID_NONE,
};
const FFBitStreamFilter ff_evc_frame_merge_bsf = {
.p.name = "evc_frame_merge",
.p.codec_ids = evc_frame_merge_codec_ids,
.priv_data_size = sizeof(EVCFMergeContext),
.init = evc_frame_merge_init,
.flush = evc_frame_merge_flush,
.close = evc_frame_merge_close,
.filter = evc_frame_merge_filter,
};