FFmpeg
vaapi_mpeg4.c
Go to the documentation of this file.
1 /*
2  * MPEG-4 / H.263 HW decode acceleration through VA API
3  *
4  * Copyright (C) 2008-2009 Splitted-Desktop Systems
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 "h263.h"
24 #include "hwconfig.h"
25 #include "internal.h"
26 #include "mpeg4video.h"
27 #include "mpegvideo.h"
28 #include "vaapi_decode.h"
29 
30 /** Reconstruct bitstream intra_dc_vlc_thr */
32 {
33  switch (s->intra_dc_threshold) {
34  case 99: return 0;
35  case 13: return 1;
36  case 15: return 2;
37  case 17: return 3;
38  case 19: return 4;
39  case 21: return 5;
40  case 23: return 6;
41  case 0: return 7;
42  }
43  return 0;
44 }
45 
46 static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
47 {
48  Mpeg4DecContext *ctx = avctx->priv_data;
49  MpegEncContext *s = &ctx->m;
50  VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
51  VAPictureParameterBufferMPEG4 pic_param;
52  int i, err;
53 
54  pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);
55 
56  pic_param = (VAPictureParameterBufferMPEG4) {
57  .vop_width = s->width,
58  .vop_height = s->height,
59  .forward_reference_picture = VA_INVALID_ID,
60  .backward_reference_picture = VA_INVALID_ID,
61  .vol_fields.bits = {
62  .short_video_header = avctx->codec->id == AV_CODEC_ID_H263,
63  .chroma_format = CHROMA_420,
64  .interlaced = !s->progressive_sequence,
65  .obmc_disable = 1,
66  .sprite_enable = ctx->vol_sprite_usage,
67  .sprite_warping_accuracy = s->sprite_warping_accuracy,
68  .quant_type = s->mpeg_quant,
69  .quarter_sample = s->quarter_sample,
70  .data_partitioned = s->data_partitioning,
71  .reversible_vlc = ctx->rvlc,
72  .resync_marker_disable = !ctx->resync_marker,
73  },
74  .no_of_sprite_warping_points = ctx->num_sprite_warping_points,
75  .quant_precision = s->quant_precision,
76  .vop_fields.bits = {
77  .vop_coding_type = s->pict_type - AV_PICTURE_TYPE_I,
78  .backward_reference_vop_coding_type =
79  s->pict_type == AV_PICTURE_TYPE_B ? s->next_picture.f->pict_type - AV_PICTURE_TYPE_I : 0,
80  .vop_rounding_type = s->no_rounding,
81  .intra_dc_vlc_thr = mpeg4_get_intra_dc_vlc_thr(ctx),
82  .top_field_first = s->top_field_first,
83  .alternate_vertical_scan_flag = s->alternate_scan,
84  },
85  .vop_fcode_forward = s->f_code,
86  .vop_fcode_backward = s->b_code,
87  .vop_time_increment_resolution = avctx->framerate.num,
88  .num_macroblocks_in_gob = s->mb_width * H263_GOB_HEIGHT(s->height),
89  .num_gobs_in_vop =
90  (s->mb_width * s->mb_height) / (s->mb_width * H263_GOB_HEIGHT(s->height)),
91  .TRB = s->pb_time,
92  .TRD = s->pp_time,
93  };
94 
95  for (i = 0; i < ctx->num_sprite_warping_points && i < 3; i++) {
96  pic_param.sprite_trajectory_du[i] = ctx->sprite_traj[i][0];
97  pic_param.sprite_trajectory_dv[i] = ctx->sprite_traj[i][1];
98  }
99 
100  if (s->pict_type == AV_PICTURE_TYPE_B)
101  pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
102  if (s->pict_type != AV_PICTURE_TYPE_I)
103  pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
104 
105  err = ff_vaapi_decode_make_param_buffer(avctx, pic,
106  VAPictureParameterBufferType,
107  &pic_param, sizeof(pic_param));
108  if (err < 0)
109  goto fail;
110 
111  /* Only the first inverse quantisation method uses the weighting matrices */
112  if (pic_param.vol_fields.bits.quant_type) {
113  VAIQMatrixBufferMPEG4 iq_matrix;
114 
115  iq_matrix.load_intra_quant_mat = 1;
116  iq_matrix.load_non_intra_quant_mat = 1;
117 
118  for (i = 0; i < 64; i++) {
119  int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
120  iq_matrix.intra_quant_mat[i] = s->intra_matrix[n];
121  iq_matrix.non_intra_quant_mat[i] = s->inter_matrix[n];
122  }
123 
124  err = ff_vaapi_decode_make_param_buffer(avctx, pic,
125  VAIQMatrixBufferType,
126  &iq_matrix, sizeof(iq_matrix));
127  if (err < 0)
128  goto fail;
129  }
130  return 0;
131 
132 fail:
133  ff_vaapi_decode_cancel(avctx, pic);
134  return err;
135 }
136 
138 {
139  MpegEncContext *s = avctx->priv_data;
140  VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
141  int ret;
142 
143  ret = ff_vaapi_decode_issue(avctx, pic);
144  if (ret < 0)
145  goto fail;
146 
147  ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
148 
149 fail:
150  return ret;
151 }
152 
153 static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
154 {
155  MpegEncContext *s = avctx->priv_data;
156  VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
157  VASliceParameterBufferMPEG4 slice_param;
158  int err;
159 
160  slice_param = (VASliceParameterBufferMPEG4) {
161  .slice_data_size = size,
162  .slice_data_offset = 0,
163  .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
164  .macroblock_offset = get_bits_count(&s->gb) % 8,
165  .macroblock_number = 0,
166  .quant_scale = s->qscale,
167  };
168 
169  err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
170  &slice_param, sizeof(slice_param),
171  buffer, size);
172  if (err < 0) {
173  ff_vaapi_decode_cancel(avctx, pic);
174  return err;
175  }
176 
177  return 0;
178 }
179 
180 #if CONFIG_MPEG4_VAAPI_HWACCEL
182  .name = "mpeg4_vaapi",
183  .type = AVMEDIA_TYPE_VIDEO,
184  .id = AV_CODEC_ID_MPEG4,
185  .pix_fmt = AV_PIX_FMT_VAAPI,
186  .start_frame = &vaapi_mpeg4_start_frame,
187  .end_frame = &vaapi_mpeg4_end_frame,
188  .decode_slice = &vaapi_mpeg4_decode_slice,
189  .frame_priv_data_size = sizeof(VAAPIDecodePicture),
192  .frame_params = &ff_vaapi_common_frame_params,
193  .priv_data_size = sizeof(VAAPIDecodeContext),
194  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
195 };
196 #endif
197 
198 #if CONFIG_H263_VAAPI_HWACCEL
200  .name = "h263_vaapi",
201  .type = AVMEDIA_TYPE_VIDEO,
202  .id = AV_CODEC_ID_H263,
203  .pix_fmt = AV_PIX_FMT_VAAPI,
204  .start_frame = &vaapi_mpeg4_start_frame,
205  .end_frame = &vaapi_mpeg4_end_frame,
206  .decode_slice = &vaapi_mpeg4_decode_slice,
207  .frame_priv_data_size = sizeof(VAAPIDecodePicture),
210  .frame_params = &ff_vaapi_common_frame_params,
211  .priv_data_size = sizeof(VAAPIDecodeContext),
212  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
213 };
214 #endif
hwconfig.h
vaapi_mpeg4_decode_slice
static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: vaapi_mpeg4.c:153
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
H263_GOB_HEIGHT
#define H263_GOB_HEIGHT(h)
Definition: h263.h:43
ff_vaapi_get_surface_id
static VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)
Definition: vaapi_decode.h:30
VAAPIDecodeContext
Definition: vaapi_decode.h:50
vaapi_decode.h
vaapi_mpeg4_end_frame
static int vaapi_mpeg4_end_frame(AVCodecContext *avctx)
Definition: vaapi_mpeg4.c:137
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
av_unused
#define av_unused
Definition: attributes.h:131
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
VAAPIDecodePicture
Definition: vaapi_decode.h:39
ff_vaapi_decode_make_slice_buffer
int ff_vaapi_decode_make_slice_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, const void *params_data, size_t params_size, const void *slice_data, size_t slice_size)
Definition: vaapi_decode.c:59
internal.h
vaapi_mpeg4_start_frame
static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: vaapi_mpeg4.c:46
mpegvideo.h
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1816
AVHWAccel
Definition: avcodec.h:2143
ff_vaapi_decode_make_param_buffer
int ff_vaapi_decode_make_param_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, int type, const void *data, size_t size)
Definition: vaapi_decode.c:30
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:510
fail
#define fail()
Definition: checkasm.h:134
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:2260
AVRational::num
int num
Numerator.
Definition: rational.h:59
VAAPIDecodePicture::output_surface
VASurfaceID output_surface
Definition: vaapi_decode.h:40
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_vaapi_decode_init
int ff_vaapi_decode_init(AVCodecContext *avctx)
Definition: vaapi_decode.c:634
ff_vaapi_common_frame_params
int ff_vaapi_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: vaapi_decode.c:610
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_vaapi_decode_uninit
int ff_vaapi_decode_uninit(AVCodecContext *avctx)
Definition: vaapi_decode.c:680
ff_vaapi_decode_issue
int ff_vaapi_decode_issue(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:151
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
Mpeg4DecContext
Definition: mpeg4video.h:74
mpeg4_get_intra_dc_vlc_thr
static int mpeg4_get_intra_dc_vlc_thr(Mpeg4DecContext *s)
Reconstruct bitstream intra_dc_vlc_thr.
Definition: vaapi_mpeg4.c:31
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:53
size
int size
Definition: twinvq_data.h:10344
ff_vaapi_decode_cancel
int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:225
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:119
AVCodec::id
enum AVCodecID id
Definition: codec.h:211
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2149
i
int i
Definition: input.c:407
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:485
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Definition: hwconfig.h:26
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
AVCodecContext
main external API structure.
Definition: avcodec.h:501
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
mpeg4video.h
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_h263_vaapi_hwaccel
const AVHWAccel ff_h263_vaapi_hwaccel
ff_mpeg4_vaapi_hwaccel
const AVHWAccel ff_mpeg4_vaapi_hwaccel
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:279
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
h263.h