mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2025-03-28 12:32:17 +02:00
avcodec/hevc_ps: Use RefStruct API for parameter sets
Avoids allocations and error checks for these allocations; e.g. syncing buffers across threads can't fail any more and needn't be checked. It also gets rid of casts and indirections. Reviewed-by: Anton Khirnov <anton@khirnov.net> Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
parent
787351a68e
commit
2db94a96c8
@ -77,15 +77,15 @@ static int hevc_parse_slice_header(AVCodecParserContext *s, H2645NAL *nal,
|
||||
av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
ps->pps = (HEVCPPS*)ps->pps_list[pps_id]->data;
|
||||
ps->pps = ps->pps_list[pps_id];
|
||||
|
||||
if (ps->pps->sps_id >= HEVC_MAX_SPS_COUNT || !ps->sps_list[ps->pps->sps_id]) {
|
||||
av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", ps->pps->sps_id);
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
if (ps->sps != (HEVCSPS*)ps->sps_list[ps->pps->sps_id]->data) {
|
||||
ps->sps = (HEVCSPS*)ps->sps_list[ps->pps->sps_id]->data;
|
||||
ps->vps = (HEVCVPS*)ps->vps_list[ps->sps->vps_id]->data;
|
||||
if (ps->sps != ps->sps_list[ps->pps->sps_id]) {
|
||||
ps->sps = ps->sps_list[ps->pps->sps_id];
|
||||
ps->vps = ps->vps_list[ps->sps->vps_id];
|
||||
}
|
||||
ow = &ps->sps->output_window;
|
||||
|
||||
|
@ -28,6 +28,7 @@
|
||||
#include "h2645_vui.h"
|
||||
#include "hevc_data.h"
|
||||
#include "hevc_ps.h"
|
||||
#include "refstruct.h"
|
||||
|
||||
static const uint8_t default_scaling_list_intra[] = {
|
||||
16, 16, 16, 16, 17, 18, 21, 24,
|
||||
@ -61,40 +62,40 @@ static const uint8_t hevc_sub_height_c[] = {
|
||||
|
||||
static void remove_pps(HEVCParamSets *s, int id)
|
||||
{
|
||||
if (s->pps_list[id] && s->pps == (const HEVCPPS*)s->pps_list[id]->data)
|
||||
if (s->pps == s->pps_list[id])
|
||||
s->pps = NULL;
|
||||
av_buffer_unref(&s->pps_list[id]);
|
||||
ff_refstruct_unref(&s->pps_list[id]);
|
||||
}
|
||||
|
||||
static void remove_sps(HEVCParamSets *s, int id)
|
||||
{
|
||||
int i;
|
||||
if (s->sps_list[id]) {
|
||||
if (s->sps == (const HEVCSPS*)s->sps_list[id]->data)
|
||||
if (s->sps == s->sps_list[id])
|
||||
s->sps = NULL;
|
||||
|
||||
/* drop all PPS that depend on this SPS */
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
|
||||
if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == id)
|
||||
if (s->pps_list[i] && s->pps_list[i]->sps_id == id)
|
||||
remove_pps(s, i);
|
||||
|
||||
av_assert0(!(s->sps_list[id] && s->sps == (HEVCSPS*)s->sps_list[id]->data));
|
||||
av_assert0(!(s->sps_list[id] && s->sps == s->sps_list[id]));
|
||||
ff_refstruct_unref(&s->sps_list[id]);
|
||||
}
|
||||
av_buffer_unref(&s->sps_list[id]);
|
||||
}
|
||||
|
||||
static void remove_vps(HEVCParamSets *s, int id)
|
||||
{
|
||||
int i;
|
||||
if (s->vps_list[id]) {
|
||||
if (s->vps == (const HEVCVPS*)s->vps_list[id]->data)
|
||||
if (s->vps == s->vps_list[id])
|
||||
s->vps = NULL;
|
||||
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
|
||||
if (s->sps_list[i] && ((HEVCSPS*)s->sps_list[i]->data)->vps_id == id)
|
||||
if (s->sps_list[i] && s->sps_list[i]->vps_id == id)
|
||||
remove_sps(s, i);
|
||||
ff_refstruct_unref(&s->vps_list[id]);
|
||||
}
|
||||
av_buffer_unref(&s->vps_list[id]);
|
||||
}
|
||||
|
||||
int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
@ -442,12 +443,10 @@ int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
int i,j;
|
||||
int vps_id = 0;
|
||||
ptrdiff_t nal_size;
|
||||
HEVCVPS *vps;
|
||||
AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
|
||||
HEVCVPS *vps = ff_refstruct_allocz(sizeof(*vps));
|
||||
|
||||
if (!vps_buf)
|
||||
if (!vps)
|
||||
return AVERROR(ENOMEM);
|
||||
vps = (HEVCVPS*)vps_buf->data;
|
||||
|
||||
av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
|
||||
|
||||
@ -553,17 +552,17 @@ int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
}
|
||||
|
||||
if (ps->vps_list[vps_id] &&
|
||||
!memcmp(ps->vps_list[vps_id]->data, vps_buf->data, vps_buf->size)) {
|
||||
av_buffer_unref(&vps_buf);
|
||||
!memcmp(ps->vps_list[vps_id], vps, sizeof(*vps))) {
|
||||
ff_refstruct_unref(&vps);
|
||||
} else {
|
||||
remove_vps(ps, vps_id);
|
||||
ps->vps_list[vps_id] = vps_buf;
|
||||
ps->vps_list[vps_id] = vps;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err:
|
||||
av_buffer_unref(&vps_buf);
|
||||
ff_refstruct_unref(&vps);
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
|
||||
@ -851,7 +850,8 @@ static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
|
||||
}
|
||||
|
||||
int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
|
||||
int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
|
||||
int apply_defdispwin, const HEVCVPS * const *vps_list,
|
||||
AVCodecContext *avctx)
|
||||
{
|
||||
HEVCWindow *ow;
|
||||
int ret = 0;
|
||||
@ -1269,15 +1269,13 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
|
||||
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
HEVCParamSets *ps, int apply_defdispwin)
|
||||
{
|
||||
HEVCSPS *sps;
|
||||
AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
|
||||
HEVCSPS *sps = ff_refstruct_allocz(sizeof(*sps));
|
||||
unsigned int sps_id;
|
||||
int ret;
|
||||
ptrdiff_t nal_size;
|
||||
|
||||
if (!sps_buf)
|
||||
if (!sps)
|
||||
return AVERROR(ENOMEM);
|
||||
sps = (HEVCSPS*)sps_buf->data;
|
||||
|
||||
av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
|
||||
|
||||
@ -1296,7 +1294,7 @@ int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
apply_defdispwin,
|
||||
ps->vps_list, avctx);
|
||||
if (ret < 0) {
|
||||
av_buffer_unref(&sps_buf);
|
||||
ff_refstruct_unref(&sps);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -1314,19 +1312,19 @@ int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
* original one.
|
||||
* otherwise drop all PPSes that depend on it */
|
||||
if (ps->sps_list[sps_id] &&
|
||||
!memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
|
||||
av_buffer_unref(&sps_buf);
|
||||
!memcmp(ps->sps_list[sps_id], sps, sizeof(*sps))) {
|
||||
ff_refstruct_unref(&sps);
|
||||
} else {
|
||||
remove_sps(ps, sps_id);
|
||||
ps->sps_list[sps_id] = sps_buf;
|
||||
ps->sps_list[sps_id] = sps;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void hevc_pps_free(void *opaque, uint8_t *data)
|
||||
static void hevc_pps_free(FFRefStructOpaque unused, void *obj)
|
||||
{
|
||||
HEVCPPS *pps = (HEVCPPS*)data;
|
||||
HEVCPPS *pps = obj;
|
||||
|
||||
av_freep(&pps->column_width);
|
||||
av_freep(&pps->row_height);
|
||||
@ -1338,8 +1336,6 @@ static void hevc_pps_free(void *opaque, uint8_t *data)
|
||||
av_freep(&pps->tile_pos_rs);
|
||||
av_freep(&pps->tile_id);
|
||||
av_freep(&pps->min_tb_addr_zs_tab);
|
||||
|
||||
av_freep(&pps);
|
||||
}
|
||||
|
||||
static void colour_mapping_octants(GetBitContext *gb, HEVCPPS *pps, int inp_depth,
|
||||
@ -1742,19 +1738,11 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
ptrdiff_t nal_size;
|
||||
unsigned log2_parallel_merge_level_minus2;
|
||||
|
||||
AVBufferRef *pps_buf;
|
||||
HEVCPPS *pps = av_mallocz(sizeof(*pps));
|
||||
HEVCPPS *pps = ff_refstruct_alloc_ext(sizeof(*pps), 0, NULL, hevc_pps_free);
|
||||
|
||||
if (!pps)
|
||||
return AVERROR(ENOMEM);
|
||||
|
||||
pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
|
||||
hevc_pps_free, NULL, 0);
|
||||
if (!pps_buf) {
|
||||
av_freep(&pps);
|
||||
return AVERROR(ENOMEM);
|
||||
}
|
||||
|
||||
av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
|
||||
|
||||
nal_size = gb->buffer_end - gb->buffer;
|
||||
@ -1796,8 +1784,8 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
ret = AVERROR_INVALIDDATA;
|
||||
goto err;
|
||||
}
|
||||
sps = (HEVCSPS *)ps->sps_list[pps->sps_id]->data;
|
||||
vps = (HEVCVPS *)ps->vps_list[sps->vps_id]->data;
|
||||
sps = ps->sps_list[pps->sps_id];
|
||||
vps = ps->vps_list[sps->vps_id];
|
||||
|
||||
pps->dependent_slice_segments_enabled_flag = get_bits1(gb);
|
||||
pps->output_flag_present_flag = get_bits1(gb);
|
||||
@ -1998,12 +1986,12 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
}
|
||||
|
||||
remove_pps(ps, pps_id);
|
||||
ps->pps_list[pps_id] = pps_buf;
|
||||
ps->pps_list[pps_id] = pps;
|
||||
|
||||
return 0;
|
||||
|
||||
err:
|
||||
av_buffer_unref(&pps_buf);
|
||||
ff_refstruct_unref(&pps);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -2012,11 +2000,11 @@ void ff_hevc_ps_uninit(HEVCParamSets *ps)
|
||||
int i;
|
||||
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(ps->vps_list); i++)
|
||||
av_buffer_unref(&ps->vps_list[i]);
|
||||
ff_refstruct_unref(&ps->vps_list[i]);
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
|
||||
av_buffer_unref(&ps->sps_list[i]);
|
||||
ff_refstruct_unref(&ps->sps_list[i]);
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
|
||||
av_buffer_unref(&ps->pps_list[i]);
|
||||
ff_refstruct_unref(&ps->pps_list[i]);
|
||||
|
||||
ps->sps = NULL;
|
||||
ps->pps = NULL;
|
||||
|
@ -23,7 +23,6 @@
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "libavutil/buffer.h"
|
||||
#include "libavutil/pixfmt.h"
|
||||
#include "libavutil/rational.h"
|
||||
|
||||
@ -437,9 +436,9 @@ typedef struct HEVCPPS {
|
||||
} HEVCPPS;
|
||||
|
||||
typedef struct HEVCParamSets {
|
||||
AVBufferRef *vps_list[HEVC_MAX_VPS_COUNT];
|
||||
AVBufferRef *sps_list[HEVC_MAX_SPS_COUNT];
|
||||
AVBufferRef *pps_list[HEVC_MAX_PPS_COUNT];
|
||||
const HEVCVPS *vps_list[HEVC_MAX_VPS_COUNT]; ///< RefStruct references
|
||||
const HEVCSPS *sps_list[HEVC_MAX_SPS_COUNT]; ///< RefStruct references
|
||||
const HEVCPPS *pps_list[HEVC_MAX_PPS_COUNT]; ///< RefStruct references
|
||||
|
||||
/* currently active parameter sets */
|
||||
const HEVCVPS *vps;
|
||||
@ -457,7 +456,8 @@ typedef struct HEVCParamSets {
|
||||
* to an existing VPS
|
||||
*/
|
||||
int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
|
||||
int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx);
|
||||
int apply_defdispwin, const HEVCVPS * const *vps_list,
|
||||
AVCodecContext *avctx);
|
||||
|
||||
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
|
||||
HEVCParamSets *ps);
|
||||
|
@ -53,11 +53,10 @@ static int decode_nal_sei_pic_timing(HEVCSEI *s, GetBitContext *gb,
|
||||
const HEVCParamSets *ps, void *logctx)
|
||||
{
|
||||
HEVCSEIPictureTiming *h = &s->picture_timing;
|
||||
HEVCSPS *sps;
|
||||
const HEVCSPS *sps = ps->sps_list[s->active_seq_parameter_set_id];
|
||||
|
||||
if (!ps->sps_list[s->active_seq_parameter_set_id])
|
||||
if (!sps)
|
||||
return(AVERROR(ENOMEM));
|
||||
sps = (HEVCSPS*)ps->sps_list[s->active_seq_parameter_set_id]->data;
|
||||
|
||||
if (sps->vui.frame_field_info_present_flag) {
|
||||
int pic_struct = get_bits(gb, 4);
|
||||
|
@ -50,6 +50,7 @@
|
||||
#include "hwconfig.h"
|
||||
#include "internal.h"
|
||||
#include "profiles.h"
|
||||
#include "refstruct.h"
|
||||
#include "thread.h"
|
||||
#include "threadframe.h"
|
||||
|
||||
@ -326,7 +327,7 @@ static void export_stream_params(HEVCContext *s, const HEVCSPS *sps)
|
||||
{
|
||||
AVCodecContext *avctx = s->avctx;
|
||||
const HEVCParamSets *ps = &s->ps;
|
||||
const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
|
||||
const HEVCVPS *vps = ps->vps_list[sps->vps_id];
|
||||
const HEVCWindow *ow = &sps->output_window;
|
||||
unsigned int num = 0, den = 0;
|
||||
|
||||
@ -573,7 +574,7 @@ static int set_sps(HEVCContext *s, const HEVCSPS *sps,
|
||||
}
|
||||
|
||||
s->ps.sps = sps;
|
||||
s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
|
||||
s->ps.vps = s->ps.vps_list[s->ps.sps->vps_id];
|
||||
|
||||
return 0;
|
||||
|
||||
@ -616,16 +617,16 @@ static int hls_slice_header(HEVCContext *s)
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
if (!sh->first_slice_in_pic_flag &&
|
||||
s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
|
||||
s->ps.pps != s->ps.pps_list[sh->pps_id]) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
|
||||
s->ps.pps = s->ps.pps_list[sh->pps_id];
|
||||
if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
|
||||
sh->no_output_of_prior_pics_flag = 1;
|
||||
|
||||
if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
|
||||
const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
|
||||
if (s->ps.sps != s->ps.sps_list[s->ps.pps->sps_id]) {
|
||||
const HEVCSPS *sps = s->ps.sps_list[s->ps.pps->sps_id];
|
||||
enum AVPixelFormat pix_fmt;
|
||||
|
||||
ff_hevc_clear_refs(s);
|
||||
@ -3304,7 +3305,7 @@ static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int f
|
||||
/* export stream parameters from the first SPS */
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
|
||||
if (first && s->ps.sps_list[i]) {
|
||||
const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
|
||||
const HEVCSPS *sps = s->ps.sps_list[i];
|
||||
export_stream_params(s, sps);
|
||||
break;
|
||||
}
|
||||
@ -3549,23 +3550,14 @@ static int hevc_update_thread_context(AVCodecContext *dst,
|
||||
|
||||
if (s->ps.sps != s0->ps.sps)
|
||||
s->ps.sps = NULL;
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
|
||||
ret = av_buffer_replace(&s->ps.vps_list[i], s0->ps.vps_list[i]);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
|
||||
ff_refstruct_replace(&s->ps.vps_list[i], s0->ps.vps_list[i]);
|
||||
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
|
||||
ret = av_buffer_replace(&s->ps.sps_list[i], s0->ps.sps_list[i]);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
|
||||
ff_refstruct_replace(&s->ps.sps_list[i], s0->ps.sps_list[i]);
|
||||
|
||||
for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
|
||||
ret = av_buffer_replace(&s->ps.pps_list[i], s0->ps.pps_list[i]);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
|
||||
ff_refstruct_replace(&s->ps.pps_list[i], s0->ps.pps_list[i]);
|
||||
|
||||
if (s->ps.sps != s0->ps.sps)
|
||||
if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
|
||||
|
@ -223,21 +223,21 @@ static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
|
||||
|
||||
for (i = 0; i < HEVC_MAX_VPS_COUNT; i++) {
|
||||
if (ps.vps_list[i]) {
|
||||
vps = (const HEVCVPS*)ps.vps_list[i]->data;
|
||||
vps = ps.vps_list[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < HEVC_MAX_PPS_COUNT; i++) {
|
||||
if (ps.pps_list[i]) {
|
||||
pps = (const HEVCPPS*)ps.pps_list[i]->data;
|
||||
pps = ps.pps_list[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (pps) {
|
||||
if (ps.sps_list[pps->sps_id]) {
|
||||
sps = (const HEVCSPS*)ps.sps_list[pps->sps_id]->data;
|
||||
sps = ps.sps_list[pps->sps_id];
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -246,7 +246,7 @@ CFDataRef ff_videotoolbox_hvcc_extradata_create(AVCodecContext *avctx)
|
||||
#define COUNT_SIZE_PS(T, t) \
|
||||
for (i = 0; i < HEVC_MAX_##T##PS_COUNT; i++) { \
|
||||
if (h->ps.t##ps_list[i]) { \
|
||||
const HEVC##T##PS *lps = (const HEVC##T##PS *)h->ps.t##ps_list[i]->data; \
|
||||
const HEVC##T##PS *lps = h->ps.t##ps_list[i]; \
|
||||
vt_extradata_size += 2 + escape_ps(NULL, lps->data, lps->data_size); \
|
||||
num_##t##ps++; \
|
||||
} \
|
||||
@ -369,7 +369,7 @@ CFDataRef ff_videotoolbox_hvcc_extradata_create(AVCodecContext *avctx)
|
||||
p += 3; \
|
||||
for (i = 0; i < HEVC_MAX_##T##PS_COUNT; i++) { \
|
||||
if (h->ps.t##ps_list[i]) { \
|
||||
const HEVC##T##PS *lps = (const HEVC##T##PS *)h->ps.t##ps_list[i]->data; \
|
||||
const HEVC##T##PS *lps = h->ps.t##ps_list[i]; \
|
||||
int size = escape_ps(p + 2, lps->data, lps->data_size); \
|
||||
/* unsigned int(16) nalUnitLength; */ \
|
||||
AV_WB16(p, size); \
|
||||
|
@ -71,14 +71,14 @@ typedef struct HEVCHeaderSet {
|
||||
static int alloc_hevc_header_structs(FFVulkanDecodeContext *s,
|
||||
int nb_vps,
|
||||
const int vps_list_idx[HEVC_MAX_VPS_COUNT],
|
||||
AVBufferRef * const vps_list[HEVC_MAX_VPS_COUNT])
|
||||
const HEVCVPS * const vps_list[HEVC_MAX_VPS_COUNT])
|
||||
{
|
||||
uint8_t *data_ptr;
|
||||
HEVCHeaderSet *hdr;
|
||||
|
||||
size_t buf_size = sizeof(HEVCHeaderSet) + nb_vps*sizeof(HEVCHeaderVPS);
|
||||
for (int i = 0; i < nb_vps; i++) {
|
||||
const HEVCVPS *vps = (const HEVCVPS *)vps_list[vps_list_idx[i]]->data;
|
||||
const HEVCVPS *vps = vps_list[vps_list_idx[i]];
|
||||
buf_size += sizeof(HEVCHeaderVPSSet)*vps->vps_num_hrd_parameters;
|
||||
}
|
||||
|
||||
@ -97,7 +97,7 @@ static int alloc_hevc_header_structs(FFVulkanDecodeContext *s,
|
||||
hdr->hvps = (HEVCHeaderVPS *)(data_ptr + sizeof(HEVCHeaderSet));
|
||||
data_ptr += sizeof(HEVCHeaderSet) + nb_vps*sizeof(HEVCHeaderVPS);
|
||||
for (int i = 0; i < nb_vps; i++) {
|
||||
const HEVCVPS *vps = (const HEVCVPS *)vps_list[vps_list_idx[i]]->data;
|
||||
const HEVCVPS *vps = vps_list[vps_list_idx[i]];
|
||||
hdr->hvps[i].sls = (HEVCHeaderVPSSet *)data_ptr;
|
||||
data_ptr += sizeof(HEVCHeaderVPSSet)*vps->vps_num_hrd_parameters;
|
||||
}
|
||||
@ -677,7 +677,7 @@ static int vk_hevc_create_params(AVCodecContext *avctx, AVBufferRef **buf)
|
||||
/* SPS list */
|
||||
for (int i = 0; i < HEVC_MAX_SPS_COUNT; i++) {
|
||||
if (h->ps.sps_list[i]) {
|
||||
const HEVCSPS *sps_l = (const HEVCSPS *)h->ps.sps_list[i]->data;
|
||||
const HEVCSPS *sps_l = h->ps.sps_list[i];
|
||||
int idx = h265_params_info.stdSPSCount++;
|
||||
set_sps(sps_l, i, &hdr->hsps[idx].scaling, &hdr->hsps[idx].vui_header,
|
||||
&hdr->hsps[idx].vui, &hdr->sps[idx], hdr->hsps[idx].nal_hdr,
|
||||
@ -689,8 +689,8 @@ static int vk_hevc_create_params(AVCodecContext *avctx, AVBufferRef **buf)
|
||||
/* PPS list */
|
||||
for (int i = 0; i < HEVC_MAX_PPS_COUNT; i++) {
|
||||
if (h->ps.pps_list[i]) {
|
||||
const HEVCPPS *pps_l = (const HEVCPPS *)h->ps.pps_list[i]->data;
|
||||
const HEVCSPS *sps_l = (const HEVCSPS *)h->ps.sps_list[pps_l->sps_id]->data;
|
||||
const HEVCPPS *pps_l = h->ps.pps_list[i];
|
||||
const HEVCSPS *sps_l = h->ps.sps_list[pps_l->sps_id];
|
||||
int idx = h265_params_info.stdPPSCount++;
|
||||
set_pps(pps_l, sps_l, &hdr->hpps[idx].scaling,
|
||||
&hdr->pps[idx], &hdr->hpps[idx].pal);
|
||||
@ -699,7 +699,7 @@ static int vk_hevc_create_params(AVCodecContext *avctx, AVBufferRef **buf)
|
||||
|
||||
/* VPS list */
|
||||
for (int i = 0; i < nb_vps; i++) {
|
||||
const HEVCVPS *vps_l = (const HEVCVPS *)h->ps.vps_list[vps_list_idx[i]]->data;
|
||||
const HEVCVPS *vps_l = h->ps.vps_list[vps_list_idx[i]];
|
||||
set_vps(vps_l, &hdr->vps[i], &hdr->hvps[i].ptl, &hdr->hvps[i].dpbm,
|
||||
hdr->hvps[i].hdr, hdr->hvps[i].sls);
|
||||
h265_params_info.stdVPSCount++;
|
||||
@ -879,7 +879,7 @@ static int vk_hevc_end_frame(AVCodecContext *avctx)
|
||||
if (!pps) {
|
||||
unsigned int pps_id = h->sh.pps_id;
|
||||
if (pps_id < HEVC_MAX_PPS_COUNT && h->ps.pps_list[pps_id] != NULL)
|
||||
pps = (const HEVCPPS *)h->ps.pps_list[pps_id]->data;
|
||||
pps = h->ps.pps_list[pps_id];
|
||||
}
|
||||
|
||||
if (!pps) {
|
||||
|
Loading…
x
Reference in New Issue
Block a user