2 * Chinese AVS video (AVS1-P2, JiZhun profile) decoder.
3 * Copyright (c) 2006 Stefan Gehrer <stefan.gehrer@gmx.de>
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
24 * Chinese AVS video (AVS1-P2, JiZhun profile) decoder
25 * @author Stefan Gehrer <stefan.gehrer@gmx.de>
31 #include "h264chroma.h"
37 static const uint8_t alpha_tab
[64] = {
38 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3,
39 4, 4, 5, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 18, 20,
40 22, 24, 26, 28, 30, 33, 33, 35, 35, 36, 37, 37, 39, 39, 42, 44,
41 46, 48, 50, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64
44 static const uint8_t beta_tab
[64] = {
45 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
46 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6,
47 6, 7, 7, 7, 8, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 14,
48 15, 16, 17, 18, 19, 20, 21, 22, 23, 23, 24, 24, 25, 25, 26, 27
51 static const uint8_t tc_tab
[64] = {
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
53 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
54 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4,
55 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9
58 /** mark block as unavailable, i.e. out of picture
59 * or not yet decoded */
60 static const cavs_vector un_mv
= { 0, 0, 1, NOT_AVAIL
};
62 static const int8_t left_modifier_l
[8] = { 0, -1, 6, -1, -1, 7, 6, 7 };
63 static const int8_t top_modifier_l
[8] = { -1, 1, 5, -1, -1, 5, 7, 7 };
64 static const int8_t left_modifier_c
[7] = { 5, -1, 2, -1, 6, 5, 6 };
65 static const int8_t top_modifier_c
[7] = { 4, 1, -1, -1, 4, 6, 6 };
67 /*****************************************************************************
69 * in-loop deblocking filter
71 ****************************************************************************/
73 static inline int get_bs(cavs_vector
*mvP
, cavs_vector
*mvQ
, int b
)
75 if ((mvP
->ref
== REF_INTRA
) || (mvQ
->ref
== REF_INTRA
))
77 if((abs(mvP
->x
- mvQ
->x
) >= 4) ||
78 (abs(mvP
->y
- mvQ
->y
) >= 4) ||
79 (mvP
->ref
!= mvQ
->ref
))
84 if((abs(mvP
->x
- mvQ
->x
) >= 4) ||
85 (abs(mvP
->y
- mvQ
->y
) >= 4) ||
86 (mvP
->ref
!= mvQ
->ref
))
93 alpha = alpha_tab[av_clip(qp_avg + h->alpha_offset, 0, 63)]; \
94 beta = beta_tab[av_clip(qp_avg + h->beta_offset, 0, 63)]; \
95 tc = tc_tab[av_clip(qp_avg + h->alpha_offset, 0, 63)];
98 * in-loop deblocking filter for a single macroblock
100 * boundary strength (bs) mapping:
109 void ff_cavs_filter(AVSContext
*h
, enum cavs_mb mb_type
)
112 int qp_avg
, alpha
, beta
, tc
;
115 /* save un-deblocked lines */
116 h
->topleft_border_y
= h
->top_border_y
[h
->mbx
* 16 + 15];
117 h
->topleft_border_u
= h
->top_border_u
[h
->mbx
* 10 + 8];
118 h
->topleft_border_v
= h
->top_border_v
[h
->mbx
* 10 + 8];
119 memcpy(&h
->top_border_y
[h
->mbx
* 16], h
->cy
+ 15 * h
->l_stride
, 16);
120 memcpy(&h
->top_border_u
[h
->mbx
* 10 + 1], h
->cu
+ 7 * h
->c_stride
, 8);
121 memcpy(&h
->top_border_v
[h
->mbx
* 10 + 1], h
->cv
+ 7 * h
->c_stride
, 8);
122 for (i
= 0; i
< 8; i
++) {
123 h
->left_border_y
[i
* 2 + 1] = *(h
->cy
+ 15 + (i
* 2 + 0) * h
->l_stride
);
124 h
->left_border_y
[i
* 2 + 2] = *(h
->cy
+ 15 + (i
* 2 + 1) * h
->l_stride
);
125 h
->left_border_u
[i
+ 1] = *(h
->cu
+ 7 + i
* h
->c_stride
);
126 h
->left_border_v
[i
+ 1] = *(h
->cv
+ 7 + i
* h
->c_stride
);
128 if (!h
->loop_filter_disable
) {
130 if (mb_type
== I_8X8
)
134 if (ff_cavs_partition_flags
[mb_type
] & SPLITV
) {
135 bs
[2] = get_bs(&h
->mv
[MV_FWD_X0
], &h
->mv
[MV_FWD_X1
], mb_type
> P_8X8
);
136 bs
[3] = get_bs(&h
->mv
[MV_FWD_X2
], &h
->mv
[MV_FWD_X3
], mb_type
> P_8X8
);
138 if (ff_cavs_partition_flags
[mb_type
] & SPLITH
) {
139 bs
[6] = get_bs(&h
->mv
[MV_FWD_X0
], &h
->mv
[MV_FWD_X2
], mb_type
> P_8X8
);
140 bs
[7] = get_bs(&h
->mv
[MV_FWD_X1
], &h
->mv
[MV_FWD_X3
], mb_type
> P_8X8
);
142 bs
[0] = get_bs(&h
->mv
[MV_FWD_A1
], &h
->mv
[MV_FWD_X0
], mb_type
> P_8X8
);
143 bs
[1] = get_bs(&h
->mv
[MV_FWD_A3
], &h
->mv
[MV_FWD_X2
], mb_type
> P_8X8
);
144 bs
[4] = get_bs(&h
->mv
[MV_FWD_B2
], &h
->mv
[MV_FWD_X0
], mb_type
> P_8X8
);
145 bs
[5] = get_bs(&h
->mv
[MV_FWD_B3
], &h
->mv
[MV_FWD_X1
], mb_type
> P_8X8
);
148 if (h
->flags
& A_AVAIL
) {
149 qp_avg
= (h
->qp
+ h
->left_qp
+ 1) >> 1;
151 h
->cdsp
.cavs_filter_lv(h
->cy
, h
->l_stride
, alpha
, beta
, tc
, bs
[0], bs
[1]);
152 qp_avg
= (ff_cavs_chroma_qp
[h
->qp
] + ff_cavs_chroma_qp
[h
->left_qp
] + 1) >> 1;
154 h
->cdsp
.cavs_filter_cv(h
->cu
, h
->c_stride
, alpha
, beta
, tc
, bs
[0], bs
[1]);
155 h
->cdsp
.cavs_filter_cv(h
->cv
, h
->c_stride
, alpha
, beta
, tc
, bs
[0], bs
[1]);
159 h
->cdsp
.cavs_filter_lv(h
->cy
+ 8, h
->l_stride
, alpha
, beta
, tc
, bs
[2], bs
[3]);
160 h
->cdsp
.cavs_filter_lh(h
->cy
+ 8 * h
->l_stride
, h
->l_stride
, alpha
, beta
, tc
, bs
[6], bs
[7]);
162 if (h
->flags
& B_AVAIL
) {
163 qp_avg
= (h
->qp
+ h
->top_qp
[h
->mbx
] + 1) >> 1;
165 h
->cdsp
.cavs_filter_lh(h
->cy
, h
->l_stride
, alpha
, beta
, tc
, bs
[4], bs
[5]);
166 qp_avg
= (ff_cavs_chroma_qp
[h
->qp
] + ff_cavs_chroma_qp
[h
->top_qp
[h
->mbx
]] + 1) >> 1;
168 h
->cdsp
.cavs_filter_ch(h
->cu
, h
->c_stride
, alpha
, beta
, tc
, bs
[4], bs
[5]);
169 h
->cdsp
.cavs_filter_ch(h
->cv
, h
->c_stride
, alpha
, beta
, tc
, bs
[4], bs
[5]);
174 h
->top_qp
[h
->mbx
] = h
->qp
;
179 /*****************************************************************************
181 * spatial intra prediction
183 ****************************************************************************/
185 void ff_cavs_load_intra_pred_luma(AVSContext
*h
, uint8_t *top
,
186 uint8_t **left
, int block
)
192 *left
= h
->left_border_y
;
193 h
->left_border_y
[0] = h
->left_border_y
[1];
194 memset(&h
->left_border_y
[17], h
->left_border_y
[16], 9);
195 memcpy(&top
[1], &h
->top_border_y
[h
->mbx
* 16], 16);
198 if ((h
->flags
& A_AVAIL
) && (h
->flags
& B_AVAIL
))
199 h
->left_border_y
[0] = top
[0] = h
->topleft_border_y
;
202 *left
= h
->intern_border_y
;
203 for (i
= 0; i
< 8; i
++)
204 h
->intern_border_y
[i
+ 1] = *(h
->cy
+ 7 + i
* h
->l_stride
);
205 memset(&h
->intern_border_y
[9], h
->intern_border_y
[8], 9);
206 h
->intern_border_y
[0] = h
->intern_border_y
[1];
207 memcpy(&top
[1], &h
->top_border_y
[h
->mbx
* 16 + 8], 8);
208 if (h
->flags
& C_AVAIL
)
209 memcpy(&top
[9], &h
->top_border_y
[(h
->mbx
+ 1) * 16], 8);
211 memset(&top
[9], top
[8], 9);
214 if (h
->flags
& B_AVAIL
)
215 h
->intern_border_y
[0] = top
[0] = h
->top_border_y
[h
->mbx
* 16 + 7];
218 *left
= &h
->left_border_y
[8];
219 memcpy(&top
[1], h
->cy
+ 7 * h
->l_stride
, 16);
222 if (h
->flags
& A_AVAIL
)
223 top
[0] = h
->left_border_y
[8];
226 *left
= &h
->intern_border_y
[8];
227 for (i
= 0; i
< 8; i
++)
228 h
->intern_border_y
[i
+ 9] = *(h
->cy
+ 7 + (i
+ 8) * h
->l_stride
);
229 memset(&h
->intern_border_y
[17], h
->intern_border_y
[16], 9);
230 memcpy(&top
[0], h
->cy
+ 7 + 7 * h
->l_stride
, 9);
231 memset(&top
[9], top
[8], 9);
236 void ff_cavs_load_intra_pred_chroma(AVSContext
*h
)
238 /* extend borders by one pixel */
239 h
->left_border_u
[9] = h
->left_border_u
[8];
240 h
->left_border_v
[9] = h
->left_border_v
[8];
241 if(h
->flags
& C_AVAIL
) {
242 h
->top_border_u
[h
->mbx
*10 + 9] = h
->top_border_u
[h
->mbx
*10 + 11];
243 h
->top_border_v
[h
->mbx
*10 + 9] = h
->top_border_v
[h
->mbx
*10 + 11];
245 h
->top_border_u
[h
->mbx
* 10 + 9] = h
->top_border_u
[h
->mbx
* 10 + 8];
246 h
->top_border_v
[h
->mbx
* 10 + 9] = h
->top_border_v
[h
->mbx
* 10 + 8];
248 if((h
->flags
& A_AVAIL
) && (h
->flags
& B_AVAIL
)) {
249 h
->top_border_u
[h
->mbx
* 10] = h
->left_border_u
[0] = h
->topleft_border_u
;
250 h
->top_border_v
[h
->mbx
* 10] = h
->left_border_v
[0] = h
->topleft_border_v
;
252 h
->left_border_u
[0] = h
->left_border_u
[1];
253 h
->left_border_v
[0] = h
->left_border_v
[1];
254 h
->top_border_u
[h
->mbx
* 10] = h
->top_border_u
[h
->mbx
* 10 + 1];
255 h
->top_border_v
[h
->mbx
* 10] = h
->top_border_v
[h
->mbx
* 10 + 1];
259 static void intra_pred_vert(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
262 uint64_t a
= AV_RN64(&top
[1]);
263 for (y
= 0; y
< 8; y
++)
264 *((uint64_t *)(d
+ y
* stride
)) = a
;
267 static void intra_pred_horiz(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
271 for (y
= 0; y
< 8; y
++) {
272 a
= left
[y
+ 1] * 0x0101010101010101ULL
;
273 *((uint64_t *)(d
+ y
* stride
)) = a
;
277 static void intra_pred_dc_128(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
280 uint64_t a
= 0x8080808080808080ULL
;
281 for (y
= 0; y
< 8; y
++)
282 *((uint64_t *)(d
+ y
* stride
)) = a
;
285 static void intra_pred_plane(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
290 const uint8_t *cm
= ff_crop_tab
+ MAX_NEG_CROP
;
292 for (x
= 0; x
< 4; x
++) {
293 ih
+= (x
+ 1) * (top
[5 + x
] - top
[3 - x
]);
294 iv
+= (x
+ 1) * (left
[5 + x
] - left
[3 - x
]);
296 ia
= (top
[8] + left
[8]) << 4;
297 ih
= (17 * ih
+ 16) >> 5;
298 iv
= (17 * iv
+ 16) >> 5;
299 for (y
= 0; y
< 8; y
++)
300 for (x
= 0; x
< 8; x
++)
301 d
[y
* stride
+ x
] = cm
[(ia
+ (x
- 3) * ih
+ (y
- 3) * iv
+ 16) >> 5];
304 #define LOWPASS(ARRAY, INDEX) \
305 ((ARRAY[(INDEX) - 1] + 2 * ARRAY[(INDEX)] + ARRAY[(INDEX) + 1] + 2) >> 2)
307 static void intra_pred_lp(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
310 for (y
= 0; y
< 8; y
++)
311 for (x
= 0; x
< 8; x
++)
312 d
[y
* stride
+ x
] = (LOWPASS(top
, x
+ 1) + LOWPASS(left
, y
+ 1)) >> 1;
315 static void intra_pred_down_left(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
318 for (y
= 0; y
< 8; y
++)
319 for (x
= 0; x
< 8; x
++)
320 d
[y
* stride
+ x
] = (LOWPASS(top
, x
+ y
+ 2) + LOWPASS(left
, x
+ y
+ 2)) >> 1;
323 static void intra_pred_down_right(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
326 for (y
= 0; y
< 8; y
++)
327 for (x
= 0; x
< 8; x
++)
329 d
[y
* stride
+ x
] = (left
[1] + 2 * top
[0] + top
[1] + 2) >> 2;
331 d
[y
* stride
+ x
] = LOWPASS(top
, x
- y
);
333 d
[y
* stride
+ x
] = LOWPASS(left
, y
- x
);
336 static void intra_pred_lp_left(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
339 for (y
= 0; y
< 8; y
++)
340 for (x
= 0; x
< 8; x
++)
341 d
[y
* stride
+ x
] = LOWPASS(left
, y
+ 1);
344 static void intra_pred_lp_top(uint8_t *d
, uint8_t *top
, uint8_t *left
, int stride
)
347 for (y
= 0; y
< 8; y
++)
348 for (x
= 0; x
< 8; x
++)
349 d
[y
* stride
+ x
] = LOWPASS(top
, x
+ 1);
354 static inline void modify_pred(const int8_t *mod_table
, int *mode
)
356 *mode
= mod_table
[*mode
];
358 av_log(NULL
, AV_LOG_ERROR
, "Illegal intra prediction mode\n");
363 void ff_cavs_modify_mb_i(AVSContext
*h
, int *pred_mode_uv
)
365 /* save pred modes before they get modified */
366 h
->pred_mode_Y
[3] = h
->pred_mode_Y
[5];
367 h
->pred_mode_Y
[6] = h
->pred_mode_Y
[8];
368 h
->top_pred_Y
[h
->mbx
* 2 + 0] = h
->pred_mode_Y
[7];
369 h
->top_pred_Y
[h
->mbx
* 2 + 1] = h
->pred_mode_Y
[8];
371 /* modify pred modes according to availability of neighbour samples */
372 if (!(h
->flags
& A_AVAIL
)) {
373 modify_pred(left_modifier_l
, &h
->pred_mode_Y
[4]);
374 modify_pred(left_modifier_l
, &h
->pred_mode_Y
[7]);
375 modify_pred(left_modifier_c
, pred_mode_uv
);
377 if (!(h
->flags
& B_AVAIL
)) {
378 modify_pred(top_modifier_l
, &h
->pred_mode_Y
[4]);
379 modify_pred(top_modifier_l
, &h
->pred_mode_Y
[5]);
380 modify_pred(top_modifier_c
, pred_mode_uv
);
384 /*****************************************************************************
386 * motion compensation
388 ****************************************************************************/
390 static inline void mc_dir_part(AVSContext
*h
, AVFrame
*pic
, int chroma_height
,
391 int delta
, int list
, uint8_t *dest_y
,
392 uint8_t *dest_cb
, uint8_t *dest_cr
,
393 int src_x_offset
, int src_y_offset
,
394 qpel_mc_func
*qpix_op
,
395 h264_chroma_mc_func chroma_op
, cavs_vector
*mv
)
397 const int mx
= mv
->x
+ src_x_offset
* 8;
398 const int my
= mv
->y
+ src_y_offset
* 8;
399 const int luma_xy
= (mx
& 3) + ((my
& 3) << 2);
400 uint8_t *src_y
= pic
->data
[0] + (mx
>> 2) + (my
>> 2) * h
->l_stride
;
401 uint8_t *src_cb
= pic
->data
[1] + (mx
>> 3) + (my
>> 3) * h
->c_stride
;
402 uint8_t *src_cr
= pic
->data
[2] + (mx
>> 3) + (my
>> 3) * h
->c_stride
;
404 int extra_height
= extra_width
;
405 const int full_mx
= mx
>> 2;
406 const int full_my
= my
>> 2;
407 const int pic_width
= 16 * h
->mb_width
;
408 const int pic_height
= 16 * h
->mb_height
;
418 if (full_mx
< 0 - extra_width
||
419 full_my
< 0 - extra_height
||
420 full_mx
+ 16 /* FIXME */ > pic_width
+ extra_width
||
421 full_my
+ 16 /* FIXME */ > pic_height
+ extra_height
) {
422 h
->vdsp
.emulated_edge_mc(h
->edge_emu_buffer
,
423 src_y
- 2 - 2 * h
->l_stride
,
424 h
->l_stride
, h
->l_stride
,
425 16 + 5, 16 + 5 /* FIXME */,
426 full_mx
- 2, full_my
- 2,
427 pic_width
, pic_height
);
428 src_y
= h
->edge_emu_buffer
+ 2 + 2 * h
->l_stride
;
432 // FIXME try variable height perhaps?
433 qpix_op
[luma_xy
](dest_y
, src_y
, h
->l_stride
);
436 h
->vdsp
.emulated_edge_mc(h
->edge_emu_buffer
, src_cb
,
437 h
->c_stride
, h
->c_stride
,
440 pic_width
>> 1, pic_height
>> 1);
441 src_cb
= h
->edge_emu_buffer
;
443 chroma_op(dest_cb
, src_cb
, h
->c_stride
, chroma_height
, mx
& 7, my
& 7);
446 h
->vdsp
.emulated_edge_mc(h
->edge_emu_buffer
, src_cr
,
447 h
->c_stride
, h
->c_stride
,
450 pic_width
>> 1, pic_height
>> 1);
451 src_cr
= h
->edge_emu_buffer
;
453 chroma_op(dest_cr
, src_cr
, h
->c_stride
, chroma_height
, mx
& 7, my
& 7);
456 static inline void mc_part_std(AVSContext
*h
, int chroma_height
, int delta
,
460 int x_offset
, int y_offset
,
461 qpel_mc_func
*qpix_put
,
462 h264_chroma_mc_func chroma_put
,
463 qpel_mc_func
*qpix_avg
,
464 h264_chroma_mc_func chroma_avg
,
467 qpel_mc_func
*qpix_op
= qpix_put
;
468 h264_chroma_mc_func chroma_op
= chroma_put
;
470 dest_y
+= x_offset
* 2 + y_offset
* h
->l_stride
* 2;
471 dest_cb
+= x_offset
+ y_offset
* h
->c_stride
;
472 dest_cr
+= x_offset
+ y_offset
* h
->c_stride
;
473 x_offset
+= 8 * h
->mbx
;
474 y_offset
+= 8 * h
->mby
;
477 AVFrame
*ref
= h
->DPB
[mv
->ref
].f
;
478 mc_dir_part(h
, ref
, chroma_height
, delta
, 0,
479 dest_y
, dest_cb
, dest_cr
, x_offset
, y_offset
,
480 qpix_op
, chroma_op
, mv
);
483 chroma_op
= chroma_avg
;
486 if ((mv
+ MV_BWD_OFFS
)->ref
>= 0) {
487 AVFrame
*ref
= h
->DPB
[0].f
;
488 mc_dir_part(h
, ref
, chroma_height
, delta
, 1,
489 dest_y
, dest_cb
, dest_cr
, x_offset
, y_offset
,
490 qpix_op
, chroma_op
, mv
+ MV_BWD_OFFS
);
494 void ff_cavs_inter(AVSContext
*h
, enum cavs_mb mb_type
)
496 if (ff_cavs_partition_flags
[mb_type
] == 0) { // 16x16
497 mc_part_std(h
, 8, 0, h
->cy
, h
->cu
, h
->cv
, 0, 0,
498 h
->cdsp
.put_cavs_qpel_pixels_tab
[0],
499 h
->h264chroma
.put_h264_chroma_pixels_tab
[0],
500 h
->cdsp
.avg_cavs_qpel_pixels_tab
[0],
501 h
->h264chroma
.avg_h264_chroma_pixels_tab
[0],
504 mc_part_std(h
, 4, 0, h
->cy
, h
->cu
, h
->cv
, 0, 0,
505 h
->cdsp
.put_cavs_qpel_pixels_tab
[1],
506 h
->h264chroma
.put_h264_chroma_pixels_tab
[1],
507 h
->cdsp
.avg_cavs_qpel_pixels_tab
[1],
508 h
->h264chroma
.avg_h264_chroma_pixels_tab
[1],
510 mc_part_std(h
, 4, 0, h
->cy
, h
->cu
, h
->cv
, 4, 0,
511 h
->cdsp
.put_cavs_qpel_pixels_tab
[1],
512 h
->h264chroma
.put_h264_chroma_pixels_tab
[1],
513 h
->cdsp
.avg_cavs_qpel_pixels_tab
[1],
514 h
->h264chroma
.avg_h264_chroma_pixels_tab
[1],
516 mc_part_std(h
, 4, 0, h
->cy
, h
->cu
, h
->cv
, 0, 4,
517 h
->cdsp
.put_cavs_qpel_pixels_tab
[1],
518 h
->h264chroma
.put_h264_chroma_pixels_tab
[1],
519 h
->cdsp
.avg_cavs_qpel_pixels_tab
[1],
520 h
->h264chroma
.avg_h264_chroma_pixels_tab
[1],
522 mc_part_std(h
, 4, 0, h
->cy
, h
->cu
, h
->cv
, 4, 4,
523 h
->cdsp
.put_cavs_qpel_pixels_tab
[1],
524 h
->h264chroma
.put_h264_chroma_pixels_tab
[1],
525 h
->cdsp
.avg_cavs_qpel_pixels_tab
[1],
526 h
->h264chroma
.avg_h264_chroma_pixels_tab
[1],
531 /*****************************************************************************
533 * motion vector prediction
535 ****************************************************************************/
537 static inline void scale_mv(AVSContext
*h
, int *d_x
, int *d_y
,
538 cavs_vector
*src
, int distp
)
540 int den
= h
->scale_den
[FFMAX(src
->ref
, 0)];
542 *d_x
= (src
->x
* distp
* den
+ 256 + (src
->x
>> 31)) >> 9;
543 *d_y
= (src
->y
* distp
* den
+ 256 + (src
->y
>> 31)) >> 9;
546 static inline void mv_pred_median(AVSContext
*h
,
552 int ax
, ay
, bx
, by
, cx
, cy
;
553 int len_ab
, len_bc
, len_ca
, len_mid
;
555 /* scale candidates according to their temporal span */
556 scale_mv(h
, &ax
, &ay
, mvA
, mvP
->dist
);
557 scale_mv(h
, &bx
, &by
, mvB
, mvP
->dist
);
558 scale_mv(h
, &cx
, &cy
, mvC
, mvP
->dist
);
559 /* find the geometrical median of the three candidates */
560 len_ab
= abs(ax
- bx
) + abs(ay
- by
);
561 len_bc
= abs(bx
- cx
) + abs(by
- cy
);
562 len_ca
= abs(cx
- ax
) + abs(cy
- ay
);
563 len_mid
= mid_pred(len_ab
, len_bc
, len_ca
);
564 if (len_mid
== len_ab
) {
567 } else if (len_mid
== len_bc
) {
576 void ff_cavs_mv(AVSContext
*h
, enum cavs_mv_loc nP
, enum cavs_mv_loc nC
,
577 enum cavs_mv_pred mode
, enum cavs_block size
, int ref
)
579 cavs_vector
*mvP
= &h
->mv
[nP
];
580 cavs_vector
*mvA
= &h
->mv
[nP
-1];
581 cavs_vector
*mvB
= &h
->mv
[nP
-4];
582 cavs_vector
*mvC
= &h
->mv
[nC
];
583 const cavs_vector
*mvP2
= NULL
;
586 mvP
->dist
= h
->dist
[mvP
->ref
];
587 if (mvC
->ref
== NOT_AVAIL
|| (nP
== MV_FWD_X3
) || (nP
== MV_BWD_X3
))
588 mvC
= &h
->mv
[nP
- 5]; // set to top-left (mvD)
589 if (mode
== MV_PRED_PSKIP
&&
590 (mvA
->ref
== NOT_AVAIL
||
591 mvB
->ref
== NOT_AVAIL
||
592 (mvA
->x
| mvA
->y
| mvA
->ref
) == 0 ||
593 (mvB
->x
| mvB
->y
| mvB
->ref
) == 0)) {
595 /* if there is only one suitable candidate, take it */
596 } else if (mvA
->ref
>= 0 && mvB
->ref
< 0 && mvC
->ref
< 0) {
598 } else if (mvA
->ref
< 0 && mvB
->ref
>= 0 && mvC
->ref
< 0) {
600 } else if (mvA
->ref
< 0 && mvB
->ref
< 0 && mvC
->ref
>= 0) {
602 } else if (mode
== MV_PRED_LEFT
&& mvA
->ref
== ref
) {
604 } else if (mode
== MV_PRED_TOP
&& mvB
->ref
== ref
) {
606 } else if (mode
== MV_PRED_TOPRIGHT
&& mvC
->ref
== ref
) {
613 mv_pred_median(h
, mvP
, mvA
, mvB
, mvC
);
615 if (mode
< MV_PRED_PSKIP
) {
616 mvP
->x
+= get_se_golomb(&h
->gb
);
617 mvP
->y
+= get_se_golomb(&h
->gb
);
622 /*****************************************************************************
626 ****************************************************************************/
629 * initialise predictors for motion vectors and intra prediction
631 void ff_cavs_init_mb(AVSContext
*h
)
635 /* copy predictors from top line (MB B and C) into cache */
636 for (i
= 0; i
< 3; i
++) {
637 h
->mv
[MV_FWD_B2
+ i
] = h
->top_mv
[0][h
->mbx
* 2 + i
];
638 h
->mv
[MV_BWD_B2
+ i
] = h
->top_mv
[1][h
->mbx
* 2 + i
];
640 h
->pred_mode_Y
[1] = h
->top_pred_Y
[h
->mbx
* 2 + 0];
641 h
->pred_mode_Y
[2] = h
->top_pred_Y
[h
->mbx
* 2 + 1];
642 /* clear top predictors if MB B is not available */
643 if (!(h
->flags
& B_AVAIL
)) {
644 h
->mv
[MV_FWD_B2
] = un_mv
;
645 h
->mv
[MV_FWD_B3
] = un_mv
;
646 h
->mv
[MV_BWD_B2
] = un_mv
;
647 h
->mv
[MV_BWD_B3
] = un_mv
;
648 h
->pred_mode_Y
[1] = h
->pred_mode_Y
[2] = NOT_AVAIL
;
649 h
->flags
&= ~(C_AVAIL
| D_AVAIL
);
653 if (h
->mbx
== h
->mb_width
- 1) // MB C not available
654 h
->flags
&= ~C_AVAIL
;
655 /* clear top-right predictors if MB C is not available */
656 if (!(h
->flags
& C_AVAIL
)) {
657 h
->mv
[MV_FWD_C2
] = un_mv
;
658 h
->mv
[MV_BWD_C2
] = un_mv
;
660 /* clear top-left predictors if MB D is not available */
661 if (!(h
->flags
& D_AVAIL
)) {
662 h
->mv
[MV_FWD_D3
] = un_mv
;
663 h
->mv
[MV_BWD_D3
] = un_mv
;
668 * save predictors for later macroblocks and increase
670 * @return 0 if end of frame is reached, 1 otherwise
672 int ff_cavs_next_mb(AVSContext
*h
)
680 /* copy mvs as predictors to the left */
681 for (i
= 0; i
<= 20; i
+= 4)
682 h
->mv
[i
] = h
->mv
[i
+ 2];
683 /* copy bottom mvs from cache to top line */
684 h
->top_mv
[0][h
->mbx
* 2 + 0] = h
->mv
[MV_FWD_X2
];
685 h
->top_mv
[0][h
->mbx
* 2 + 1] = h
->mv
[MV_FWD_X3
];
686 h
->top_mv
[1][h
->mbx
* 2 + 0] = h
->mv
[MV_BWD_X2
];
687 h
->top_mv
[1][h
->mbx
* 2 + 1] = h
->mv
[MV_BWD_X3
];
688 /* next MB address */
691 if (h
->mbx
== h
->mb_width
) { // New mb line
692 h
->flags
= B_AVAIL
| C_AVAIL
;
693 /* clear left pred_modes */
694 h
->pred_mode_Y
[3] = h
->pred_mode_Y
[6] = NOT_AVAIL
;
695 /* clear left mv predictors */
696 for (i
= 0; i
<= 20; i
+= 4)
700 /* re-calculate sample pointers */
701 h
->cy
= h
->cur
.f
->data
[0] + h
->mby
* 16 * h
->l_stride
;
702 h
->cu
= h
->cur
.f
->data
[1] + h
->mby
* 8 * h
->c_stride
;
703 h
->cv
= h
->cur
.f
->data
[2] + h
->mby
* 8 * h
->c_stride
;
704 if (h
->mby
== h
->mb_height
) { // Frame end
711 /*****************************************************************************
715 ****************************************************************************/
717 int ff_cavs_init_pic(AVSContext
*h
)
721 /* clear some predictors */
722 for (i
= 0; i
<= 20; i
+= 4)
724 h
->mv
[MV_BWD_X0
] = ff_cavs_dir_mv
;
725 set_mvs(&h
->mv
[MV_BWD_X0
], BLK_16X16
);
726 h
->mv
[MV_FWD_X0
] = ff_cavs_dir_mv
;
727 set_mvs(&h
->mv
[MV_FWD_X0
], BLK_16X16
);
728 h
->pred_mode_Y
[3] = h
->pred_mode_Y
[6] = NOT_AVAIL
;
729 h
->cy
= h
->cur
.f
->data
[0];
730 h
->cu
= h
->cur
.f
->data
[1];
731 h
->cv
= h
->cur
.f
->data
[2];
732 h
->l_stride
= h
->cur
.f
->linesize
[0];
733 h
->c_stride
= h
->cur
.f
->linesize
[1];
734 h
->luma_scan
[2] = 8 * h
->l_stride
;
735 h
->luma_scan
[3] = 8 * h
->l_stride
+ 8;
736 h
->mbx
= h
->mby
= h
->mbidx
= 0;
742 /*****************************************************************************
744 * headers and interface
746 ****************************************************************************/
749 * some predictions require data from the top-neighbouring macroblock.
750 * this data has to be stored for one complete row of macroblocks
751 * and this storage space is allocated here
753 void ff_cavs_init_top_lines(AVSContext
*h
)
755 /* alloc top line of predictors */
756 h
->top_qp
= av_mallocz(h
->mb_width
);
757 h
->top_mv
[0] = av_mallocz_array(h
->mb_width
* 2 + 1, sizeof(cavs_vector
));
758 h
->top_mv
[1] = av_mallocz_array(h
->mb_width
* 2 + 1, sizeof(cavs_vector
));
759 h
->top_pred_Y
= av_mallocz_array(h
->mb_width
* 2, sizeof(*h
->top_pred_Y
));
760 h
->top_border_y
= av_mallocz_array(h
->mb_width
+ 1, 16);
761 h
->top_border_u
= av_mallocz_array(h
->mb_width
, 10);
762 h
->top_border_v
= av_mallocz_array(h
->mb_width
, 10);
764 /* alloc space for co-located MVs and types */
765 h
->col_mv
= av_mallocz_array(h
->mb_width
* h
->mb_height
,
766 4 * sizeof(cavs_vector
));
767 h
->col_type_base
= av_mallocz(h
->mb_width
* h
->mb_height
);
768 h
->block
= av_mallocz(64 * sizeof(int16_t));
771 av_cold
int ff_cavs_init(AVCodecContext
*avctx
)
773 AVSContext
*h
= avctx
->priv_data
;
775 ff_blockdsp_init(&h
->bdsp
, avctx
);
776 ff_h264chroma_init(&h
->h264chroma
, 8);
777 ff_idctdsp_init(&h
->idsp
, avctx
);
778 ff_videodsp_init(&h
->vdsp
, 8);
779 ff_cavsdsp_init(&h
->cdsp
, avctx
);
780 ff_init_scantable_permutation(h
->idsp
.idct_permutation
,
782 ff_init_scantable(h
->idsp
.idct_permutation
, &h
->scantable
, ff_zigzag_direct
);
785 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
787 h
->cur
.f
= av_frame_alloc();
788 h
->DPB
[0].f
= av_frame_alloc();
789 h
->DPB
[1].f
= av_frame_alloc();
790 if (!h
->cur
.f
|| !h
->DPB
[0].f
|| !h
->DPB
[1].f
) {
792 return AVERROR(ENOMEM
);
797 h
->intra_pred_l
[INTRA_L_VERT
] = intra_pred_vert
;
798 h
->intra_pred_l
[INTRA_L_HORIZ
] = intra_pred_horiz
;
799 h
->intra_pred_l
[INTRA_L_LP
] = intra_pred_lp
;
800 h
->intra_pred_l
[INTRA_L_DOWN_LEFT
] = intra_pred_down_left
;
801 h
->intra_pred_l
[INTRA_L_DOWN_RIGHT
] = intra_pred_down_right
;
802 h
->intra_pred_l
[INTRA_L_LP_LEFT
] = intra_pred_lp_left
;
803 h
->intra_pred_l
[INTRA_L_LP_TOP
] = intra_pred_lp_top
;
804 h
->intra_pred_l
[INTRA_L_DC_128
] = intra_pred_dc_128
;
805 h
->intra_pred_c
[INTRA_C_LP
] = intra_pred_lp
;
806 h
->intra_pred_c
[INTRA_C_HORIZ
] = intra_pred_horiz
;
807 h
->intra_pred_c
[INTRA_C_VERT
] = intra_pred_vert
;
808 h
->intra_pred_c
[INTRA_C_PLANE
] = intra_pred_plane
;
809 h
->intra_pred_c
[INTRA_C_LP_LEFT
] = intra_pred_lp_left
;
810 h
->intra_pred_c
[INTRA_C_LP_TOP
] = intra_pred_lp_top
;
811 h
->intra_pred_c
[INTRA_C_DC_128
] = intra_pred_dc_128
;
817 av_cold
int ff_cavs_end(AVCodecContext
*avctx
)
819 AVSContext
*h
= avctx
->priv_data
;
821 av_frame_free(&h
->cur
.f
);
822 av_frame_free(&h
->DPB
[0].f
);
823 av_frame_free(&h
->DPB
[1].f
);
826 av_free(h
->top_mv
[0]);
827 av_free(h
->top_mv
[1]);
828 av_free(h
->top_pred_Y
);
829 av_free(h
->top_border_y
);
830 av_free(h
->top_border_u
);
831 av_free(h
->top_border_v
);
833 av_free(h
->col_type_base
);
835 av_freep(&h
->edge_emu_buffer
);