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 #include "hwaccel_internal.h"
32 
33 static void dpb_add(const H264Context *h, CUVIDH264DPBENTRY *dst, const H264Picture *src,
34  int frame_idx)
35 {
36  FrameDecodeData *fdd = (FrameDecodeData*)src->f->private_ref->data;
37  const NVDECFrame *cf = fdd->hwaccel_priv;
38 
39  dst->PicIdx = cf ? cf->idx : -1;
40  dst->FrameIdx = frame_idx;
41  dst->is_long_term = src->long_ref;
42  dst->not_existing = 0;
43  dst->used_for_reference = src->reference & 3;
44  dst->FieldOrderCnt[0] = src->field_poc[0];
45  dst->FieldOrderCnt[1] = src->field_poc[1];
46 }
47 
49  const uint8_t *buffer, uint32_t size)
50 {
51  const H264Context *h = avctx->priv_data;
52  const PPS *pps = h->ps.pps;
53  const SPS *sps = h->ps.sps;
54 
56  CUVIDPICPARAMS *pp = &ctx->pic_params;
57  CUVIDH264PICPARAMS *ppc = &pp->CodecSpecific.h264;
58  FrameDecodeData *fdd;
59  NVDECFrame *cf;
60 
61  int i, dpb_size, ret;
62 
63  ret = ff_nvdec_start_frame(avctx, h->cur_pic_ptr->f);
64  if (ret < 0)
65  return ret;
66 
67  fdd = (FrameDecodeData*)h->cur_pic_ptr->f->private_ref->data;
68  cf = (NVDECFrame*)fdd->hwaccel_priv;
69 
70  *pp = (CUVIDPICPARAMS) {
71  .PicWidthInMbs = h->mb_width,
72  .FrameHeightInMbs = h->mb_height,
73  .CurrPicIdx = cf->idx,
74  .field_pic_flag = FIELD_PICTURE(h),
75  .bottom_field_flag = h->picture_structure == PICT_BOTTOM_FIELD,
76  .second_field = FIELD_PICTURE(h) && !h->first_field,
77  .ref_pic_flag = h->nal_ref_idc != 0,
78  .intra_pic_flag = 1,
79 
80  .CodecSpecific.h264 = {
81  .log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4,
82  .pic_order_cnt_type = sps->poc_type,
83  .log2_max_pic_order_cnt_lsb_minus4 = FFMAX(sps->log2_max_poc_lsb - 4, 0),
84  .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
85  .frame_mbs_only_flag = sps->frame_mbs_only_flag,
86  .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
87  .num_ref_frames = sps->ref_frame_count,
88  .residual_colour_transform_flag = sps->residual_color_transform_flag,
89  .bit_depth_luma_minus8 = sps->bit_depth_luma - 8,
90  .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8,
91  .qpprime_y_zero_transform_bypass_flag = sps->transform_bypass,
92 
93  .entropy_coding_mode_flag = pps->cabac,
94  .pic_order_present_flag = pps->pic_order_present,
95  .num_ref_idx_l0_active_minus1 = pps->ref_count[0] - 1,
96  .num_ref_idx_l1_active_minus1 = pps->ref_count[1] - 1,
97  .weighted_pred_flag = pps->weighted_pred,
98  .weighted_bipred_idc = pps->weighted_bipred_idc,
99  .pic_init_qp_minus26 = pps->init_qp - 26,
100  .deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present,
101  .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present,
102  .transform_8x8_mode_flag = pps->transform_8x8_mode,
103  .MbaffFrameFlag = sps->mb_aff && !FIELD_PICTURE(h),
104  .constrained_intra_pred_flag = pps->constrained_intra_pred,
105  .chroma_qp_index_offset = pps->chroma_qp_index_offset[0],
106  .second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1],
107  .ref_pic_flag = h->nal_ref_idc != 0,
108  .frame_num = h->poc.frame_num,
109  .CurrFieldOrderCnt[0] = h->cur_pic_ptr->field_poc[0],
110  .CurrFieldOrderCnt[1] = h->cur_pic_ptr->field_poc[1],
111  },
112  };
113 
114  memcpy(ppc->WeightScale4x4, pps->scaling_matrix4, sizeof(ppc->WeightScale4x4));
115  memcpy(ppc->WeightScale8x8[0], pps->scaling_matrix8[0], sizeof(ppc->WeightScale8x8[0]));
116  memcpy(ppc->WeightScale8x8[1], pps->scaling_matrix8[3], sizeof(ppc->WeightScale8x8[0]));
117 
118  dpb_size = 0;
119  for (i = 0; i < h->short_ref_count; i++)
120  dpb_add(h, &ppc->dpb[dpb_size++], h->short_ref[i], h->short_ref[i]->frame_num);
121  for (i = 0; i < 16; i++) {
122  if (h->long_ref[i])
123  dpb_add(h, &ppc->dpb[dpb_size++], h->long_ref[i], i);
124  }
125 
126  for (i = dpb_size; i < FF_ARRAY_ELEMS(ppc->dpb); i++)
127  ppc->dpb[i].PicIdx = -1;
128 
129  return 0;
130 }
131 
132 static int nvdec_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
133  uint32_t size)
134 {
136  CUVIDPICPARAMS *pp = &ctx->pic_params;
137  const H264Context *h = avctx->priv_data;
138  const H264SliceContext *sl = &h->slice_ctx[0];
139  void *tmp;
140 
141  tmp = av_fast_realloc(ctx->bitstream_internal, &ctx->bitstream_allocated,
142  ctx->bitstream_len + size + 3);
143  if (!tmp)
144  return AVERROR(ENOMEM);
145  ctx->bitstream = ctx->bitstream_internal = tmp;
146 
147  tmp = av_fast_realloc(ctx->slice_offsets, &ctx->slice_offsets_allocated,
148  (ctx->nb_slices + 1) * sizeof(*ctx->slice_offsets));
149  if (!tmp)
150  return AVERROR(ENOMEM);
151  ctx->slice_offsets = tmp;
152 
153  AV_WB24(ctx->bitstream_internal + ctx->bitstream_len, 1);
154  memcpy(ctx->bitstream_internal + ctx->bitstream_len + 3, buffer, size);
155  ctx->slice_offsets[ctx->nb_slices] = ctx->bitstream_len ;
156  ctx->bitstream_len += size + 3;
157  ctx->nb_slices++;
158 
160  pp->intra_pic_flag = 0;
161 
162  return 0;
163 }
164 
166  AVBufferRef *hw_frames_ctx)
167 {
168  const H264Context *h = avctx->priv_data;
169  const SPS *sps = h->ps.sps;
170  return ff_nvdec_frame_params(avctx, hw_frames_ctx, sps->ref_frame_count + sps->num_reorder_frames, 0);
171 }
172 
174  .p.name = "h264_nvdec",
175  .p.type = AVMEDIA_TYPE_VIDEO,
176  .p.id = AV_CODEC_ID_H264,
177  .p.pix_fmt = AV_PIX_FMT_CUDA,
178  .start_frame = nvdec_h264_start_frame,
179  .end_frame = ff_nvdec_end_frame,
180  .decode_slice = nvdec_h264_decode_slice,
181  .frame_params = nvdec_h264_frame_params,
182  .init = ff_nvdec_decode_init,
183  .uninit = ff_nvdec_decode_uninit,
184  .priv_data_size = sizeof(NVDECContext),
185 };
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
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
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
FrameDecodeData
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
Definition: decode.h:33
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:172
FFHWAccel
Definition: hwaccel_internal.h:34
ff_nvdec_start_frame
int ff_nvdec_start_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: nvdec.c:560
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:67
NVDECFrame
Definition: nvdec.h:44
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
H264SliceContext::slice_type
int slice_type
Definition: h264dec.h:178
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
dpb_size
int dpb_size
Definition: h264_levels.c:111
hwaccel_internal.h
ff_nvdec_decode_init
int ff_nvdec_decode_init(AVCodecContext *avctx)
Definition: nvdec.c:326
SPS
Sequence parameter set.
Definition: h264_ps.h:44
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:283
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
PPS
Picture parameter set.
Definition: h264_ps.h:110
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:33
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:121
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:448
nvdec.h
ff_nvdec_decode_uninit
int ff_nvdec_decode_uninit(AVCodecContext *avctx)
Definition: nvdec.c:258
nvdec_h264_start_frame
static int nvdec_h264_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: nvdec_h264.c:48
nvdec_h264_frame_params
static int nvdec_h264_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: nvdec_h264.c:165
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2139
h264dec.h
H264Context
H264Context.
Definition: h264dec.h:332
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ff_nvdec_end_frame
int ff_nvdec_end_frame(AVCodecContext *avctx)
Definition: nvdec.c:632
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:132
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:445
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:692
H264Picture
Definition: h264dec.h:106
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:472
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
ff_h264_nvdec_hwaccel
const FFHWAccel ff_h264_nvdec_hwaccel
Definition: nvdec_h264.c:173
FrameDecodeData::hwaccel_priv
void * hwaccel_priv
Per-frame private data for hwaccels.
Definition: decode.h:51
h
h
Definition: vp9dsp_template.c:2038
NVDECContext
Definition: nvdec.h:52