FFmpeg
nvdec_h264.c
Go to the documentation of this file.
1 /*
2  * MPEG-4 Part 10 / AVC / H.264 HW decode acceleration through NVDEC
3  *
4  * Copyright (c) 2016 Anton Khirnov
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <stdint.h>
24 #include <string.h>
25 
26 #include "avcodec.h"
27 #include "nvdec.h"
28 #include "decode.h"
29 #include "internal.h"
30 #include "h264dec.h"
31 
32 static void dpb_add(const H264Context *h, CUVIDH264DPBENTRY *dst, const H264Picture *src,
33  int frame_idx)
34 {
35  FrameDecodeData *fdd = (FrameDecodeData*)src->f->private_ref->data;
36  const NVDECFrame *cf = fdd->hwaccel_priv;
37 
38  dst->PicIdx = cf ? cf->idx : -1;
39  dst->FrameIdx = frame_idx;
40  dst->is_long_term = src->long_ref;
41  dst->not_existing = 0;
42  dst->used_for_reference = src->reference & 3;
43  dst->FieldOrderCnt[0] = src->field_poc[0];
44  dst->FieldOrderCnt[1] = src->field_poc[1];
45 }
46 
48  const uint8_t *buffer, uint32_t size)
49 {
50  const H264Context *h = avctx->priv_data;
51  const PPS *pps = h->ps.pps;
52  const SPS *sps = h->ps.sps;
53 
55  CUVIDPICPARAMS *pp = &ctx->pic_params;
56  CUVIDH264PICPARAMS *ppc = &pp->CodecSpecific.h264;
57  FrameDecodeData *fdd;
58  NVDECFrame *cf;
59 
60  int i, dpb_size, ret;
61 
62  ret = ff_nvdec_start_frame(avctx, h->cur_pic_ptr->f);
63  if (ret < 0)
64  return ret;
65 
66  fdd = (FrameDecodeData*)h->cur_pic_ptr->f->private_ref->data;
67  cf = (NVDECFrame*)fdd->hwaccel_priv;
68 
69  *pp = (CUVIDPICPARAMS) {
70  .PicWidthInMbs = h->mb_width,
71  .FrameHeightInMbs = h->mb_height,
72  .CurrPicIdx = cf->idx,
73  .field_pic_flag = FIELD_PICTURE(h),
74  .bottom_field_flag = h->picture_structure == PICT_BOTTOM_FIELD,
75  .second_field = FIELD_PICTURE(h) && !h->first_field,
76  .ref_pic_flag = h->nal_ref_idc != 0,
77  .intra_pic_flag = 1,
78 
79  .CodecSpecific.h264 = {
80  .log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4,
81  .pic_order_cnt_type = sps->poc_type,
82  .log2_max_pic_order_cnt_lsb_minus4 = FFMAX(sps->log2_max_poc_lsb - 4, 0),
83  .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
84  .frame_mbs_only_flag = sps->frame_mbs_only_flag,
85  .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
86  .num_ref_frames = sps->ref_frame_count,
87  .residual_colour_transform_flag = sps->residual_color_transform_flag,
88  .bit_depth_luma_minus8 = sps->bit_depth_luma - 8,
89  .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8,
90  .qpprime_y_zero_transform_bypass_flag = sps->transform_bypass,
91 
92  .entropy_coding_mode_flag = pps->cabac,
93  .pic_order_present_flag = pps->pic_order_present,
94  .num_ref_idx_l0_active_minus1 = pps->ref_count[0] - 1,
95  .num_ref_idx_l1_active_minus1 = pps->ref_count[1] - 1,
96  .weighted_pred_flag = pps->weighted_pred,
97  .weighted_bipred_idc = pps->weighted_bipred_idc,
98  .pic_init_qp_minus26 = pps->init_qp - 26,
99  .deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present,
100  .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present,
101  .transform_8x8_mode_flag = pps->transform_8x8_mode,
102  .MbaffFrameFlag = sps->mb_aff && !FIELD_PICTURE(h),
103  .constrained_intra_pred_flag = pps->constrained_intra_pred,
104  .chroma_qp_index_offset = pps->chroma_qp_index_offset[0],
105  .second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1],
106  .ref_pic_flag = h->nal_ref_idc != 0,
107  .frame_num = h->poc.frame_num,
108  .CurrFieldOrderCnt[0] = h->cur_pic_ptr->field_poc[0],
109  .CurrFieldOrderCnt[1] = h->cur_pic_ptr->field_poc[1],
110  },
111  };
112 
113  memcpy(ppc->WeightScale4x4, pps->scaling_matrix4, sizeof(ppc->WeightScale4x4));
114  memcpy(ppc->WeightScale8x8[0], pps->scaling_matrix8[0], sizeof(ppc->WeightScale8x8[0]));
115  memcpy(ppc->WeightScale8x8[1], pps->scaling_matrix8[3], sizeof(ppc->WeightScale8x8[0]));
116 
117  dpb_size = 0;
118  for (i = 0; i < h->short_ref_count; i++)
119  dpb_add(h, &ppc->dpb[dpb_size++], h->short_ref[i], h->short_ref[i]->frame_num);
120  for (i = 0; i < 16; i++) {
121  if (h->long_ref[i])
122  dpb_add(h, &ppc->dpb[dpb_size++], h->long_ref[i], i);
123  }
124 
125  for (i = dpb_size; i < FF_ARRAY_ELEMS(ppc->dpb); i++)
126  ppc->dpb[i].PicIdx = -1;
127 
128  return 0;
129 }
130 
131 static int nvdec_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
132  uint32_t size)
133 {
135  CUVIDPICPARAMS *pp = &ctx->pic_params;
136  const H264Context *h = avctx->priv_data;
137  const H264SliceContext *sl = &h->slice_ctx[0];
138  void *tmp;
139 
140  tmp = av_fast_realloc(ctx->bitstream, &ctx->bitstream_allocated,
141  ctx->bitstream_len + size + 3);
142  if (!tmp)
143  return AVERROR(ENOMEM);
144  ctx->bitstream = tmp;
145 
146  tmp = av_fast_realloc(ctx->slice_offsets, &ctx->slice_offsets_allocated,
147  (ctx->nb_slices + 1) * sizeof(*ctx->slice_offsets));
148  if (!tmp)
149  return AVERROR(ENOMEM);
150  ctx->slice_offsets = tmp;
151 
152  AV_WB24(ctx->bitstream + ctx->bitstream_len, 1);
153  memcpy(ctx->bitstream + ctx->bitstream_len + 3, buffer, size);
154  ctx->slice_offsets[ctx->nb_slices] = ctx->bitstream_len ;
155  ctx->bitstream_len += size + 3;
156  ctx->nb_slices++;
157 
159  pp->intra_pic_flag = 0;
160 
161  return 0;
162 }
163 
165  AVBufferRef *hw_frames_ctx)
166 {
167  const H264Context *h = avctx->priv_data;
168  const SPS *sps = h->ps.sps;
169  return ff_nvdec_frame_params(avctx, hw_frames_ctx, sps->ref_frame_count + sps->num_reorder_frames, 0);
170 }
171 
173  .name = "h264_nvdec",
174  .type = AVMEDIA_TYPE_VIDEO,
175  .id = AV_CODEC_ID_H264,
176  .pix_fmt = AV_PIX_FMT_CUDA,
177  .start_frame = nvdec_h264_start_frame,
178  .end_frame = ff_nvdec_end_frame,
179  .decode_slice = nvdec_h264_decode_slice,
180  .frame_params = nvdec_h264_frame_params,
181  .init = ff_nvdec_decode_init,
182  .uninit = ff_nvdec_decode_uninit,
183  .priv_data_size = sizeof(NVDECContext),
184 };
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:253
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
FrameDecodeData
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:34
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
internal.h
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
H264SliceContext
Definition: h264dec.h:170
AVHWAccel
Definition: avcodec.h:2076
ff_nvdec_start_frame
int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: nvdec.c:569
ff_h264_nvdec_hwaccel
const AVHWAccel ff_h264_nvdec_hwaccel
Definition: nvdec_h264.c:172
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:495
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:68
NVDECFrame
Definition: nvdec.h:44
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
H264SliceContext::slice_type
int slice_type
Definition: h264dec.h:176
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
dpb_size
int dpb_size
Definition: h264_levels.c:107
ff_nvdec_decode_init
int ff_nvdec_decode_init(AVCodecContext *avctx)
Definition: nvdec.c:333
SPS
Sequence parameter set.
Definition: h264_ps.h:45
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:461
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:278
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
PPS
Picture parameter set.
Definition: h264_ps.h:105
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
dpb_add
static void dpb_add(const H264Context *h, CUVIDH264DPBENTRY *dst, const H264Picture *src, int frame_idx)
Definition: nvdec_h264.c:32
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:137
NVDECFrame::idx
unsigned int idx
Definition: nvdec.h:45
size
int size
Definition: twinvq_data.h:10344
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
nvdec.h
ff_nvdec_decode_uninit
int ff_nvdec_decode_uninit(AVCodecContext *avctx)
Definition: nvdec.c:265
nvdec_h264_start_frame
static int nvdec_h264_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: nvdec_h264.c:47
nvdec_h264_frame_params
static int nvdec_h264_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: nvdec_h264.c:164
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2082
h264dec.h
H264Context
H264Context.
Definition: h264dec.h:330
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
ff_nvdec_end_frame
int ff_nvdec_end_frame(AVCodecContext *avctx)
Definition: nvdec.c:645
avcodec.h
nvdec_h264_decode_slice
static int nvdec_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: nvdec_h264.c:131
ret
ret
Definition: filter_design.txt:187
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
AVCodecContext
main external API structure.
Definition: avcodec.h:426
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ff_nvdec_frame_params
int ff_nvdec_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx, int dpb_size, int supports_444)
Definition: nvdec.c:705
H264Picture
Definition: h264dec.h:107
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:453
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:52
h
h
Definition: vp9dsp_template.c:2038
NVDECContext
Definition: nvdec.h:52