2 * XVideo Motion Compensation
3 * Copyright (c) 2003 Ivan Kalvachev
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include <X11/extensions/XvMC.h>
26 #include "mpegutils.h"
27 #include "mpegvideo.h"
33 #include "xvmc_internal.h"
37 * Initialize the block field of the MpegEncContext pointer passed as
38 * parameter after making sure that the data is not corrupted.
39 * In order to implement something like direct rendering instead of decoding
40 * coefficients in s->blocks and then copying them, copy them directly
41 * into the data_blocks array provided by xvmc.
43 void ff_xvmc_init_block(MpegEncContext
*s
)
45 struct xvmc_pix_fmt
*render
= (struct xvmc_pix_fmt
*)s
->current_picture
.f
->data
[2];
46 assert(render
&& render
->xvmc_id
== AV_XVMC_ID
);
48 s
->block
= (int16_t (*)[64])(render
->data_blocks
+ render
->next_free_data_block_num
* 64);
51 static void exchange_uv(MpegEncContext
*s
)
56 s
->pblocks
[4] = s
->pblocks
[5];
61 * Fill individual block pointers, so there are no gaps in the data_block array
62 * in case not all blocks in the macroblock are coded.
64 void ff_xvmc_pack_pblocks(MpegEncContext
*s
, int cbp
)
67 const int mb_block_count
= 4 + (1 << s
->chroma_format
);
69 cbp
<<= 12-mb_block_count
;
70 for (i
= 0; i
< mb_block_count
; i
++) {
72 s
->pblocks
[i
] = &s
->block
[j
++];
83 * Find and store the surfaces that are used as reference frames.
84 * This function should be called for every new field and/or frame.
85 * It should be safe to call the function a few times for the same field.
87 static int ff_xvmc_field_start(AVCodecContext
*avctx
, const uint8_t *buf
, uint32_t buf_size
)
89 struct MpegEncContext
*s
= avctx
->priv_data
;
90 struct xvmc_pix_fmt
*last
, *next
, *render
= (struct xvmc_pix_fmt
*)s
->current_picture
.f
->data
[2];
91 const int mb_block_count
= 4 + (1 << s
->chroma_format
);
94 if (!render
|| render
->xvmc_id
!= AV_XVMC_ID
||
95 !render
->data_blocks
|| !render
->mv_blocks
||
96 (unsigned int)render
->allocated_mv_blocks
> INT_MAX
/(64*6) ||
97 (unsigned int)render
->allocated_data_blocks
> INT_MAX
/64 ||
99 av_log(avctx
, AV_LOG_ERROR
,
100 "Render token doesn't look as expected.\n");
101 return -1; // make sure that this is a render packet
104 if (render
->filled_mv_blocks_num
) {
105 av_log(avctx
, AV_LOG_ERROR
,
106 "Rendering surface contains %i unprocessed blocks.\n",
107 render
->filled_mv_blocks_num
);
110 if (render
->allocated_mv_blocks
< 1 ||
111 render
->allocated_data_blocks
< render
->allocated_mv_blocks
*mb_block_count
||
112 render
->start_mv_blocks_num
>= render
->allocated_mv_blocks
||
113 render
->next_free_data_block_num
>
114 render
->allocated_data_blocks
-
115 mb_block_count
*(render
->allocated_mv_blocks
-render
->start_mv_blocks_num
)) {
116 av_log(avctx
, AV_LOG_ERROR
,
117 "Rendering surface doesn't provide enough block structures to work with.\n");
121 render
->picture_structure
= s
->picture_structure
;
122 render
->flags
= s
->first_field
? 0 : XVMC_SECOND_FIELD
;
123 render
->p_future_surface
= NULL
;
124 render
->p_past_surface
= NULL
;
126 switch(s
->pict_type
) {
127 case AV_PICTURE_TYPE_I
:
128 return 0; // no prediction from other frames
129 case AV_PICTURE_TYPE_B
:
130 next
= (struct xvmc_pix_fmt
*)s
->next_picture
.f
->data
[2];
133 if (next
->xvmc_id
!= AV_XVMC_ID
)
135 render
->p_future_surface
= next
->p_surface
;
136 // no return here, going to set forward prediction
137 case AV_PICTURE_TYPE_P
:
138 last
= (struct xvmc_pix_fmt
*)s
->last_picture
.f
->data
[2];
140 last
= render
; // predict second field from the first
141 if (last
->xvmc_id
!= AV_XVMC_ID
)
143 render
->p_past_surface
= last
->p_surface
;
151 * Complete frame/field rendering by passing any remaining blocks.
152 * Normally ff_draw_horiz_band() is called for each slice, however,
153 * some leftover blocks, for example from error_resilience(), may remain.
154 * It should be safe to call the function a few times for the same field.
156 static int ff_xvmc_field_end(AVCodecContext
*avctx
)
158 struct MpegEncContext
*s
= avctx
->priv_data
;
159 struct xvmc_pix_fmt
*render
= (struct xvmc_pix_fmt
*)s
->current_picture
.f
->data
[2];
162 if (render
->filled_mv_blocks_num
> 0)
163 ff_mpeg_draw_horiz_band(s
, 0, 0);
168 * Synthesize the data needed by XvMC to render one macroblock of data.
169 * Fill all relevant fields, if necessary do IDCT.
171 static void ff_xvmc_decode_mb(struct MpegEncContext
*s
)
173 XvMCMacroBlock
*mv_block
;
174 struct xvmc_pix_fmt
*render
;
175 int i
, cbp
, blocks_per_mb
;
177 const int mb_xy
= s
->mb_y
* s
->mb_stride
+ s
->mb_x
;
181 av_log(s
->avctx
, AV_LOG_ERROR
, "XVMC doesn't support encoding!!!\n");
185 // from ff_mpv_decode_mb(), update DC predictors for P macroblocks
189 s
->last_dc
[2] = 128 << s
->intra_dc_precision
;
192 // MC doesn't skip blocks
196 // Do I need to export quant when I could not perform postprocessing?
197 // Anyway, it doesn't hurt.
198 s
->current_picture
.qscale_table
[mb_xy
] = s
->qscale
;
200 // start of XVMC-specific code
201 render
= (struct xvmc_pix_fmt
*)s
->current_picture
.f
->data
[2];
203 assert(render
->xvmc_id
== AV_XVMC_ID
);
204 assert(render
->mv_blocks
);
206 // take the next free macroblock
207 mv_block
= &render
->mv_blocks
[render
->start_mv_blocks_num
+
208 render
->filled_mv_blocks_num
];
210 mv_block
->x
= s
->mb_x
;
211 mv_block
->y
= s
->mb_y
;
212 mv_block
->dct_type
= s
->interlaced_dct
; // XVMC_DCT_TYPE_FRAME/FIELD;
214 mv_block
->macroblock_type
= XVMC_MB_TYPE_INTRA
; // no MC, all done
216 mv_block
->macroblock_type
= XVMC_MB_TYPE_PATTERN
;
218 if (s
->mv_dir
& MV_DIR_FORWARD
) {
219 mv_block
->macroblock_type
|= XVMC_MB_TYPE_MOTION_FORWARD
;
220 // PMV[n][dir][xy] = mv[dir][n][xy]
221 mv_block
->PMV
[0][0][0] = s
->mv
[0][0][0];
222 mv_block
->PMV
[0][0][1] = s
->mv
[0][0][1];
223 mv_block
->PMV
[1][0][0] = s
->mv
[0][1][0];
224 mv_block
->PMV
[1][0][1] = s
->mv
[0][1][1];
226 if (s
->mv_dir
& MV_DIR_BACKWARD
) {
227 mv_block
->macroblock_type
|= XVMC_MB_TYPE_MOTION_BACKWARD
;
228 mv_block
->PMV
[0][1][0] = s
->mv
[1][0][0];
229 mv_block
->PMV
[0][1][1] = s
->mv
[1][0][1];
230 mv_block
->PMV
[1][1][0] = s
->mv
[1][1][0];
231 mv_block
->PMV
[1][1][1] = s
->mv
[1][1][1];
236 mv_block
->motion_type
= XVMC_PREDICTION_FRAME
;
239 mv_block
->motion_type
= XVMC_PREDICTION_16x8
;
242 mv_block
->motion_type
= XVMC_PREDICTION_FIELD
;
243 if (s
->picture_structure
== PICT_FRAME
) {
244 mv_block
->PMV
[0][0][1] <<= 1;
245 mv_block
->PMV
[1][0][1] <<= 1;
246 mv_block
->PMV
[0][1][1] <<= 1;
247 mv_block
->PMV
[1][1][1] <<= 1;
251 mv_block
->motion_type
= XVMC_PREDICTION_DUAL_PRIME
;
252 if (s
->picture_structure
== PICT_FRAME
) {
254 mv_block
->PMV
[0][0][0] = s
->mv
[0][0][0]; // top from top
255 mv_block
->PMV
[0][0][1] = s
->mv
[0][0][1] << 1;
257 mv_block
->PMV
[0][1][0] = s
->mv
[0][0][0]; // bottom from bottom
258 mv_block
->PMV
[0][1][1] = s
->mv
[0][0][1] << 1;
260 mv_block
->PMV
[1][0][0] = s
->mv
[0][2][0]; // dmv00, top from bottom
261 mv_block
->PMV
[1][0][1] = s
->mv
[0][2][1] << 1; // dmv01
263 mv_block
->PMV
[1][1][0] = s
->mv
[0][3][0]; // dmv10, bottom from top
264 mv_block
->PMV
[1][1][1] = s
->mv
[0][3][1] << 1; // dmv11
267 mv_block
->PMV
[0][1][0] = s
->mv
[0][2][0]; // dmv00
268 mv_block
->PMV
[0][1][1] = s
->mv
[0][2][1]; // dmv01
275 mv_block
->motion_vertical_field_select
= 0;
277 // set correct field references
278 if (s
->mv_type
== MV_TYPE_FIELD
|| s
->mv_type
== MV_TYPE_16X8
) {
279 mv_block
->motion_vertical_field_select
|= s
->field_select
[0][0];
280 mv_block
->motion_vertical_field_select
|= s
->field_select
[1][0] << 1;
281 mv_block
->motion_vertical_field_select
|= s
->field_select
[0][1] << 2;
282 mv_block
->motion_vertical_field_select
|= s
->field_select
[1][1] << 3;
285 // time to handle data blocks
286 mv_block
->index
= render
->next_free_data_block_num
;
289 if (s
->chroma_format
>= 2) {
290 blocks_per_mb
= 4 + (1 << s
->chroma_format
);
295 for (i
= 0; i
< blocks_per_mb
; i
++) {
297 if (s
->block_last_index
[i
] >= 0)
301 if (s
->flags
& CODEC_FLAG_GRAY
) {
302 if (s
->mb_intra
) { // intra frames are always full chroma blocks
303 for (i
= 4; i
< blocks_per_mb
; i
++) {
304 memset(s
->pblocks
[i
], 0, sizeof(*s
->pblocks
[i
])); // so we need to clear them
305 if (!render
->unsigned_intra
)
306 *s
->pblocks
[i
][0] = 1 << 10;
309 cbp
&= 0xf << (blocks_per_mb
- 4);
310 blocks_per_mb
= 4; // luminance blocks only
313 mv_block
->coded_block_pattern
= cbp
;
315 mv_block
->macroblock_type
&= ~XVMC_MB_TYPE_PATTERN
;
317 for (i
= 0; i
< blocks_per_mb
; i
++) {
318 if (s
->block_last_index
[i
] >= 0) {
319 // I do not have unsigned_intra MOCO to test, hope it is OK.
320 if (s
->mb_intra
&& (render
->idct
|| !render
->unsigned_intra
))
321 *s
->pblocks
[i
][0] -= 1 << 10;
323 s
->idsp
.idct(*s
->pblocks
[i
]);
324 /* It is unclear if MC hardware requires pixel diff values to be
325 * in the range [-255;255]. TODO: Clipping if such hardware is
326 * ever found. As of now it would only be an unnecessary
329 // copy blocks only if the codec doesn't support pblocks reordering
330 if (!s
->pack_pblocks
) {
331 memcpy(&render
->data_blocks
[render
->next_free_data_block_num
*64],
332 s
->pblocks
[i
], sizeof(*s
->pblocks
[i
]));
334 render
->next_free_data_block_num
++;
337 render
->filled_mv_blocks_num
++;
339 assert(render
->filled_mv_blocks_num
<= render
->allocated_mv_blocks
);
340 assert(render
->next_free_data_block_num
<= render
->allocated_data_blocks
);
341 /* The above conditions should not be able to fail as long as this function
342 * is used and the following 'if ()' automatically calls a callback to free
346 if (render
->filled_mv_blocks_num
== render
->allocated_mv_blocks
)
347 ff_mpeg_draw_horiz_band(s
, 0, 0);
350 #if CONFIG_MPEG1_XVMC_HWACCEL
351 AVHWAccel ff_mpeg1_xvmc_hwaccel
= {
352 .name
= "mpeg1_xvmc",
353 .type
= AVMEDIA_TYPE_VIDEO
,
354 .id
= AV_CODEC_ID_MPEG1VIDEO
,
355 .pix_fmt
= AV_PIX_FMT_XVMC
,
356 .start_frame
= ff_xvmc_field_start
,
357 .end_frame
= ff_xvmc_field_end
,
358 .decode_slice
= NULL
,
359 .decode_mb
= ff_xvmc_decode_mb
,
364 #if CONFIG_MPEG2_XVMC_HWACCEL
365 AVHWAccel ff_mpeg2_xvmc_hwaccel
= {
366 .name
= "mpeg2_xvmc",
367 .type
= AVMEDIA_TYPE_VIDEO
,
368 .id
= AV_CODEC_ID_MPEG2VIDEO
,
369 .pix_fmt
= AV_PIX_FMT_XVMC
,
370 .start_frame
= ff_xvmc_field_start
,
371 .end_frame
= ff_xvmc_field_end
,
372 .decode_slice
= NULL
,
373 .decode_mb
= ff_xvmc_decode_mb
,