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 "vaapi_internal.h"
24 #include "h263.h"
25 
26 /** Reconstruct bitstream intra_dc_vlc_thr */
28 {
29  switch (s->intra_dc_threshold) {
30  case 99: return 0;
31  case 13: return 1;
32  case 15: return 2;
33  case 17: return 3;
34  case 19: return 4;
35  case 21: return 5;
36  case 23: return 6;
37  case 0: return 7;
38  }
39  return 0;
40 }
41 
43 {
44  MpegEncContext * const s = avctx->priv_data;
45  struct vaapi_context * const vactx = avctx->hwaccel_context;
46  VAPictureParameterBufferMPEG4 *pic_param;
47  VAIQMatrixBufferMPEG4 *iq_matrix;
48  int i;
49 
50  av_dlog(avctx, "vaapi_mpeg4_start_frame()\n");
51 
52  vactx->slice_param_size = sizeof(VASliceParameterBufferMPEG4);
53 
54  /* Fill in VAPictureParameterBufferMPEG4 */
55  pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferMPEG4));
56  if (!pic_param)
57  return -1;
58  pic_param->vop_width = s->width;
59  pic_param->vop_height = s->height;
60  pic_param->forward_reference_picture = VA_INVALID_ID;
61  pic_param->backward_reference_picture = VA_INVALID_ID;
62  pic_param->vol_fields.value = 0; /* reset all bits */
63  pic_param->vol_fields.bits.short_video_header = avctx->codec->id == AV_CODEC_ID_H263;
64  pic_param->vol_fields.bits.chroma_format = CHROMA_420;
65  pic_param->vol_fields.bits.interlaced = !s->progressive_sequence;
66  pic_param->vol_fields.bits.obmc_disable = 1;
67  pic_param->vol_fields.bits.sprite_enable = s->vol_sprite_usage;
68  pic_param->vol_fields.bits.sprite_warping_accuracy = s->sprite_warping_accuracy;
69  pic_param->vol_fields.bits.quant_type = s->mpeg_quant;
70  pic_param->vol_fields.bits.quarter_sample = s->quarter_sample;
71  pic_param->vol_fields.bits.data_partitioned = s->data_partitioning;
72  pic_param->vol_fields.bits.reversible_vlc = s->rvlc;
73  pic_param->vol_fields.bits.resync_marker_disable = !s->resync_marker;
74  pic_param->no_of_sprite_warping_points = s->num_sprite_warping_points;
75  for (i = 0; i < s->num_sprite_warping_points && i < 3; i++) {
76  pic_param->sprite_trajectory_du[i] = s->sprite_traj[i][0];
77  pic_param->sprite_trajectory_dv[i] = s->sprite_traj[i][1];
78  }
79  pic_param->quant_precision = s->quant_precision;
80  pic_param->vop_fields.value = 0; /* reset all bits */
81  pic_param->vop_fields.bits.vop_coding_type = s->pict_type - AV_PICTURE_TYPE_I;
82  pic_param->vop_fields.bits.backward_reference_vop_coding_type = s->pict_type == AV_PICTURE_TYPE_B ? s->next_picture.f.pict_type - AV_PICTURE_TYPE_I : 0;
83  pic_param->vop_fields.bits.vop_rounding_type = s->no_rounding;
84  pic_param->vop_fields.bits.intra_dc_vlc_thr = mpeg4_get_intra_dc_vlc_thr(s);
85  pic_param->vop_fields.bits.top_field_first = s->top_field_first;
86  pic_param->vop_fields.bits.alternate_vertical_scan_flag = s->alternate_scan;
87  pic_param->vop_fcode_forward = s->f_code;
88  pic_param->vop_fcode_backward = s->b_code;
89  pic_param->vop_time_increment_resolution = avctx->time_base.den;
90  pic_param->num_macroblocks_in_gob = s->mb_width * ff_h263_get_gob_height(s);
91  pic_param->num_gobs_in_vop = (s->mb_width * s->mb_height) / pic_param->num_macroblocks_in_gob;
92  pic_param->TRB = s->pb_time;
93  pic_param->TRD = s->pp_time;
94 
96  pic_param->backward_reference_picture = ff_vaapi_get_surface_id(&s->next_picture);
97  if (s->pict_type != AV_PICTURE_TYPE_I)
98  pic_param->forward_reference_picture = ff_vaapi_get_surface_id(&s->last_picture);
99 
100  /* Fill in VAIQMatrixBufferMPEG4 */
101  /* Only the first inverse quantisation method uses the weighting matrices */
102  if (pic_param->vol_fields.bits.quant_type) {
103  iq_matrix = ff_vaapi_alloc_iq_matrix(vactx, sizeof(VAIQMatrixBufferMPEG4));
104  if (!iq_matrix)
105  return -1;
106  iq_matrix->load_intra_quant_mat = 1;
107  iq_matrix->load_non_intra_quant_mat = 1;
108 
109  for (i = 0; i < 64; i++) {
111  iq_matrix->intra_quant_mat[i] = s->intra_matrix[n];
112  iq_matrix->non_intra_quant_mat[i] = s->inter_matrix[n];
113  }
114  }
115  return 0;
116 }
117 
118 static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
119 {
120  MpegEncContext * const s = avctx->priv_data;
121  VASliceParameterBufferMPEG4 *slice_param;
122 
123  av_dlog(avctx, "vaapi_mpeg4_decode_slice(): buffer %p, size %d\n", buffer, size);
124 
125  /* video_plane_with_short_video_header() contains all GOBs
126  * in-order, and this is what VA API (Intel backend) expects: only
127  * a single slice param. So fake macroblock_number for FFmpeg so
128  * that we don't call vaapi_mpeg4_decode_slice() again
129  */
130  if (avctx->codec->id == AV_CODEC_ID_H263)
131  size = s->gb.buffer_end - buffer;
132 
133  /* Fill in VASliceParameterBufferMPEG4 */
134  slice_param = (VASliceParameterBufferMPEG4 *)ff_vaapi_alloc_slice(avctx->hwaccel_context, buffer, size);
135  if (!slice_param)
136  return -1;
137  slice_param->macroblock_offset = get_bits_count(&s->gb) % 8;
138  slice_param->macroblock_number = s->mb_y * s->mb_width + s->mb_x;
139  slice_param->quant_scale = s->qscale;
140 
141  if (avctx->codec->id == AV_CODEC_ID_H263)
142  s->mb_y = s->mb_height;
143 
144  return 0;
145 }
146 
147 #if CONFIG_MPEG4_VAAPI_HWACCEL
148 AVHWAccel ff_mpeg4_vaapi_hwaccel = {
149  .name = "mpeg4_vaapi",
150  .type = AVMEDIA_TYPE_VIDEO,
151  .id = AV_CODEC_ID_MPEG4,
152  .pix_fmt = AV_PIX_FMT_VAAPI_VLD,
153  .start_frame = vaapi_mpeg4_start_frame,
154  .end_frame = ff_vaapi_mpeg_end_frame,
155  .decode_slice = vaapi_mpeg4_decode_slice,
156 };
157 #endif
158 
159 #if CONFIG_H263_VAAPI_HWACCEL
160 AVHWAccel ff_h263_vaapi_hwaccel = {
161  .name = "h263_vaapi",
162  .type = AVMEDIA_TYPE_VIDEO,
163  .id = AV_CODEC_ID_H263,
164  .pix_fmt = AV_PIX_FMT_VAAPI_VLD,
165  .start_frame = vaapi_mpeg4_start_frame,
166  .end_frame = ff_vaapi_mpeg_end_frame,
167  .decode_slice = vaapi_mpeg4_decode_slice,
168 };
169 #endif
const struct AVCodec * codec
const char * s
Definition: avisynth_c.h:668
int sprite_warping_accuracy
Definition: mpegvideo.h:586
HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the b...
Definition: pixfmt.h:126
int num_sprite_warping_points
Definition: mpegvideo.h:571
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
This structure is used to share data between the FFmpeg library and the client video application...
Definition: vaapi.h:50
uint16_t sprite_traj[4][2]
sprite trajectory points
Definition: mpegvideo.h:573
int qscale
QP.
Definition: mpegvideo.h:369
int quant_precision
Definition: mpegvideo.h:578
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
initialize output if(nPeaks >3)%at least 3 peaks in spectrum for trying to find f0 nf0peaks
int intra_dc_threshold
QP above whch the ac VLC should be used for intra dc.
Definition: mpegvideo.h:595
uint8_t
void * hwaccel_context
Hardware accelerator context.
static int mpeg4_get_intra_dc_vlc_thr(MpegEncContext *s)
Reconstruct bitstream intra_dc_vlc_thr.
Definition: vaapi_mpeg4.c:27
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:439
int resync_marker
could this stream contain resync markers
Definition: mpegvideo.h:591
#define CHROMA_420
Definition: mpegvideo.h:676
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:193
uint16_t pp_time
time distance between the last 2 p,s,i frames
Definition: mpegvideo.h:560
uint8_t idct_permutation[64]
idct input permutation.
Definition: dsputil.h:249
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:277
enum AVCodecID id
static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: vaapi_mpeg4.c:118
void * ff_vaapi_alloc_pic_param(struct vaapi_context *vactx, unsigned int size)
Allocate a new picture parameter buffer.
Definition: vaapi.c:133
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:579
int vol_sprite_usage
Definition: mpegvideo.h:565
GetBitContext gb
Definition: mpegvideo.h:649
int size
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:144
int top_field_first
Definition: mpegvideo.h:668
const char * name
Name of the hardware accelerated codec.
int ff_h263_get_gob_height(MpegEncContext *s)
Get the GOB height based on picture height.
Definition: h263.c:377
int alternate_scan
Definition: mpegvideo.h:672
unsigned int slice_param_size
Size of a VASliceParameterBuffer element.
Definition: vaapi.h:137
uint16_t inter_matrix[64]
Definition: mpegvideo.h:474
AVHWAccel.
main external API structure.
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:245
VASliceParameterBufferBase * ff_vaapi_alloc_slice(struct vaapi_context *vactx, const uint8_t *buffer, uint32_t size)
Allocate a new slice descriptor for the input slice.
Definition: vaapi.c:148
int data_partitioning
data partitioning flag from header
Definition: mpegvideo.h:588
int progressive_sequence
Definition: mpegvideo.h:658
synthesis window for stochastic i
DSPContext dsp
pointers for accelerated dsp functions
Definition: mpegvideo.h:391
int f_code
forward MV resolution
Definition: mpegvideo.h:395
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:377
MpegEncContext.
Definition: mpegvideo.h:241
static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: vaapi_mpeg4.c:42
int rvlc
reversible vlc
Definition: mpegvideo.h:590
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:115
const uint8_t * buffer_end
Definition: get_bits.h:55
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:325
void * ff_vaapi_alloc_iq_matrix(struct vaapi_context *vactx, unsigned int size)
Allocate a new IQ matrix buffer.
Definition: vaapi.c:138
Bi-dir predicted.
Definition: avutil.h:218
the buffer and buffer 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 AVFilterBuffer structures They must not be accessed but through references stored in AVFilterBufferRef structures Several references can point to the same buffer
int den
denominator
Definition: rational.h:45
static VASurfaceID ff_vaapi_get_surface_id(Picture *pic)
Extract VASurfaceID from a Picture.
Picture next_picture
copy of the next picture structure.
Definition: mpegvideo.h:331
struct AVFrame f
Definition: mpegvideo.h:98
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:472
int ff_vaapi_mpeg_end_frame(AVCodecContext *avctx)
Definition: vaapi.c:197
int b_code
backward MV resolution for B Frames (mpeg4)
Definition: mpegvideo.h:396
#define av_unused
Definition: attributes.h:114
uint16_t pb_time
time distance between the last b and p,s,i frame
Definition: mpegvideo.h:561