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 Libav.
7 * Libav 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 * Libav 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 Libav; 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"
35 static const uint8_t alpha_tab
[64] = {
36 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3,
37 4, 4, 5, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 18, 20,
38 22, 24, 26, 28, 30, 33, 33, 35, 35, 36, 37, 37, 39, 39, 42, 44,
39 46, 48, 50, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64
42 static const uint8_t beta_tab
[64] = {
43 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
44 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6,
45 6, 7, 7, 7, 8, 8, 8, 9, 9, 10, 10, 11, 11, 12, 13, 14,
46 15, 16, 17, 18, 19, 20, 21, 22, 23, 23, 24, 24, 25, 25, 26, 27
49 static const uint8_t tc_tab
[64] = {
50 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
51 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
52 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4,
53 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9
56 /** mark block as unavailable, i.e. out of picture
58 static const cavs_vector un_mv
= { 0, 0, 1, NOT_AVAIL
};
60 static const int8_t left_modifier_l
[8] = { 0, -1, 6, -1, -1, 7, 6, 7 };
61 static const int8_t top_modifier_l
[8] = { -1, 1, 5, -1, -1, 5, 7, 7 };
62 static const int8_t left_modifier_c
[7] = { 5, -1, 2, -1, 6, 5, 6 };
63 static const int8_t top_modifier_c
[7] = { 4, 1, -1, -1, 4, 6, 6 };
65 /*****************************************************************************
67 * in-loop deblocking filter
69 ****************************************************************************/
71 static inline int get_bs(cavs_vector
*mvP
, cavs_vector
*mvQ
, int b
)
73 if ((mvP
->ref
== REF_INTRA
) || (mvQ
->ref
== REF_INTRA
))
75 if ((abs(mvP
->x
- mvQ
->x
) >= 4) || (abs(mvP
->y
- mvQ
->y
) >= 4))
80 if ((abs(mvP
->x
- mvQ
->x
) >= 4) || (abs(mvP
->y
- mvQ
->y
) >= 4))
83 if (mvP
->ref
!= mvQ
->ref
)
90 alpha = alpha_tab[av_clip(qp_avg + h->alpha_offset, 0, 63)]; \
91 beta = beta_tab[av_clip(qp_avg + h->beta_offset, 0, 63)]; \
92 tc = tc_tab[av_clip(qp_avg + h->alpha_offset, 0, 63)];
95 * in-loop deblocking filter for a single macroblock
97 * boundary strength (bs) mapping:
106 void ff_cavs_filter(AVSContext
*h
, enum cavs_mb mb_type
)
109 int qp_avg
, alpha
, beta
, tc
;
112 /* save un-deblocked lines */
113 h
->topleft_border_y
= h
->top_border_y
[h
->mbx
* 16 + 15];
114 h
->topleft_border_u
= h
->top_border_u
[h
->mbx
* 10 + 8];
115 h
->topleft_border_v
= h
->top_border_v
[h
->mbx
* 10 + 8];
116 memcpy(&h
->top_border_y
[h
->mbx
* 16], h
->cy
+ 15 * h
->l_stride
, 16);
117 memcpy(&h
->top_border_u
[h
->mbx
* 10 + 1], h
->cu
+ 7 * h
->c_stride
, 8);
118 memcpy(&h
->top_border_v
[h
->mbx
* 10 + 1], h
->cv
+ 7 * h
->c_stride
, 8);
119 for (i
= 0; i
< 8; i
++) {
120 h
->left_border_y
[i
* 2 + 1] = *(h
->cy
+ 15 + (i
* 2 + 0) * h
->l_stride
);
121 h
->left_border_y
[i
* 2 + 2] = *(h
->cy
+ 15 + (i
* 2 + 1) * h
->l_stride
);
122 h
->left_border_u
[i
+ 1] = *(h
->cu
+ 7 + i
* h
->c_stride
);
123 h
->left_border_v
[i
+ 1] = *(h
->cv
+ 7 + i
* h
->c_stride
);
125 if (!h
->loop_filter_disable
) {
127 if (mb_type
== I_8X8
)
131 if (ff_cavs_partition_flags
[mb_type
] & SPLITV
) {
132 bs
[2] = get_bs(&h
->mv
[MV_FWD_X0
], &h
->mv
[MV_FWD_X1
], mb_type
> P_8X8
);
133 bs
[3] = get_bs(&h
->mv
[MV_FWD_X2
], &h
->mv
[MV_FWD_X3
], mb_type
> P_8X8
);
135 if (ff_cavs_partition_flags
[mb_type
] & SPLITH
) {
136 bs
[6] = get_bs(&h
->mv
[MV_FWD_X0
], &h
->mv
[MV_FWD_X2
], mb_type
> P_8X8
);
137 bs
[7] = get_bs(&h
->mv
[MV_FWD_X1
], &h
->mv
[MV_FWD_X3
], mb_type
> P_8X8
);
139 bs
[0] = get_bs(&h
->mv
[MV_FWD_A1
], &h
->mv
[MV_FWD_X0
], mb_type
> P_8X8
);
140 bs
[1] = get_bs(&h
->mv
[MV_FWD_A3
], &h
->mv
[MV_FWD_X2
], mb_type
> P_8X8
);
141 bs
[4] = get_bs(&h
->mv
[MV_FWD_B2
], &h
->mv
[MV_FWD_X0
], mb_type
> P_8X8
);
142 bs
[5] = get_bs(&h
->mv
[MV_FWD_B3
], &h
->mv
[MV_FWD_X1
], mb_type
> P_8X8
);
145 if (h
->flags
& A_AVAIL
) {
146 qp_avg
= (h
->qp
+ h
->left_qp
+ 1) >> 1;
148 h
->cdsp
.cavs_filter_lv(h
->cy
, h
->l_stride
, alpha
, beta
, tc
, bs
[0], bs
[1]);
149 h
->cdsp
.cavs_filter_cv(h
->cu
, h
->c_stride
, alpha
, beta
, tc
, bs
[0], bs
[1]);
150 h
->cdsp
.cavs_filter_cv(h
->cv
, h
->c_stride
, alpha
, beta
, tc
, bs
[0], bs
[1]);
154 h
->cdsp
.cavs_filter_lv(h
->cy
+ 8, h
->l_stride
, alpha
, beta
, tc
, bs
[2], bs
[3]);
155 h
->cdsp
.cavs_filter_lh(h
->cy
+ 8 * h
->l_stride
, h
->l_stride
, alpha
, beta
, tc
, bs
[6], bs
[7]);
157 if (h
->flags
& B_AVAIL
) {
158 qp_avg
= (h
->qp
+ h
->top_qp
[h
->mbx
] + 1) >> 1;
160 h
->cdsp
.cavs_filter_lh(h
->cy
, h
->l_stride
, alpha
, beta
, tc
, bs
[4], bs
[5]);
161 h
->cdsp
.cavs_filter_ch(h
->cu
, h
->c_stride
, alpha
, beta
, tc
, bs
[4], bs
[5]);
162 h
->cdsp
.cavs_filter_ch(h
->cv
, h
->c_stride
, alpha
, beta
, tc
, bs
[4], bs
[5]);
167 h
->top_qp
[h
->mbx
] = h
->qp
;
172 /*****************************************************************************
174 * spatial intra prediction
176 ****************************************************************************/
178 void ff_cavs_load_intra_pred_luma(AVSContext
*h
, uint8_t *top
,
179 uint8_t **left
, int block
)
185 *left
= h
->left_border_y
;
186 h
->left_border_y
[0] = h
->left_border_y
[1];
187 memset(&h
->left_border_y
[17], h
->left_border_y
[16], 9);
188 memcpy(&top
[1], &h
->top_border_y
[h
->mbx
* 16], 16);
191 if ((h
->flags
& A_AVAIL
) && (h
->flags
& B_AVAIL
))
192 h
->left_border_y
[0] = top
[0] = h
->topleft_border_y
;
195 *left
= h
->intern_border_y
;
196 for (i
= 0; i
< 8; i
++)
197 h
->intern_border_y
[i
+ 1] = *(h
->cy
+ 7 + i
* h
->l_stride
);
198 memset(&h
->intern_border_y
[9], h
->intern_border_y
[8], 9);
199 h
->intern_border_y
[0] = h
->intern_border_y
[1];
200 memcpy(&top
[1], &h
->top_border_y
[h
->mbx
* 16 + 8], 8);
201 if (h
->flags
& C_AVAIL
)
202 memcpy(&top
[9], &h
->top_border_y
[(h
->mbx
+ 1) * 16], 8);
204 memset(&top
[9], top
[8], 9);
207 if (h
->flags
& B_AVAIL
)
208 h
->intern_border_y
[0] = top
[0] = h
->top_border_y
[h
->mbx
* 16 + 7];
211 *left
= &h
->left_border_y
[8];
212 memcpy(&top
[1], h
->cy
+ 7 * h
->l_stride
, 16);
215 if (h
->flags
& A_AVAIL
)
216 top
[0] = h
->left_border_y
[8];
219 *left
= &h
->intern_border_y
[8];
220 for (i
= 0; i
< 8; i
++)
221 h
->intern_border_y
[i
+ 9] = *(h
->cy
+ 7 + (i
+ 8) * h
->l_stride
);
222 memset(&h
->intern_border_y
[17], h
->intern_border_y
[16], 9);
223 memcpy(&top
[0], h
->cy
+ 7 + 7 * h
->l_stride
, 9);
224 memset(&top
[9], top
[8], 9);
229 void ff_cavs_load_intra_pred_chroma(AVSContext
*h
)
231 /* extend borders by one pixel */
232 h
->left_border_u
[9] = h
->left_border_u
[8];
233 h
->left_border_v
[9] = h
->left_border_v
[8];
234 h
->top_border_u
[h
->mbx
* 10 + 9] = h
->top_border_u
[h
->mbx
* 10 + 8];
235 h
->top_border_v
[h
->mbx
* 10 + 9] = h
->top_border_v
[h
->mbx
* 10 + 8];
236 if (h
->mbx
&& h
->mby
) {
237 h
->top_border_u
[h
->mbx
* 10] = h
->left_border_u
[0] = h
->topleft_border_u
;
238 h
->top_border_v
[h
->mbx
* 10] = h
->left_border_v
[0] = h
->topleft_border_v
;
240 h
->left_border_u
[0] = h
->left_border_u
[1];
241 h
->left_border_v
[0] = h
->left_border_v
[1];
242 h
->top_border_u
[h
->mbx
* 10] = h
->top_border_u
[h
->mbx
* 10 + 1];
243 h
->top_border_v
[h
->mbx
* 10] = h
->top_border_v
[h
->mbx
* 10 + 1];
247 static void intra_pred_vert(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
250 uint64_t a
= AV_RN64(&top
[1]);
251 for (y
= 0; y
< 8; y
++) {
252 *((uint64_t *)(d
+ y
* stride
)) = a
;
256 static void intra_pred_horiz(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
260 for (y
= 0; y
< 8; y
++) {
261 a
= left
[y
+ 1] * 0x0101010101010101ULL
;
262 *((uint64_t *)(d
+ y
* stride
)) = a
;
266 static void intra_pred_dc_128(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
269 uint64_t a
= 0x8080808080808080ULL
;
270 for (y
= 0; y
< 8; y
++)
271 *((uint64_t *)(d
+ y
* stride
)) = a
;
274 static void intra_pred_plane(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
279 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
281 for (x
= 0; x
< 4; x
++) {
282 ih
+= (x
+ 1) * (top
[5 + x
] - top
[3 - x
]);
283 iv
+= (x
+ 1) * (left
[5 + x
] - left
[3 - x
]);
285 ia
= (top
[8] + left
[8]) << 4;
286 ih
= (17 * ih
+ 16) >> 5;
287 iv
= (17 * iv
+ 16) >> 5;
288 for (y
= 0; y
< 8; y
++)
289 for (x
= 0; x
< 8; x
++)
290 d
[y
* stride
+ x
] = cm
[(ia
+ (x
- 3) * ih
+ (y
- 3) * iv
+ 16) >> 5];
293 #define LOWPASS(ARRAY,INDEX) \
294 ((ARRAY[(INDEX) - 1] + 2 * ARRAY[(INDEX)] + ARRAY[(INDEX) + 1] + 2) >> 2)
296 static void intra_pred_lp(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
299 for (y
= 0; y
< 8; y
++)
300 for (x
= 0; x
< 8; x
++)
301 d
[y
* stride
+ x
] = (LOWPASS(top
, x
+ 1) + LOWPASS(left
, y
+ 1)) >> 1;
304 static void intra_pred_down_left(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
307 for (y
= 0; y
< 8; y
++)
308 for (x
= 0; x
< 8; x
++)
309 d
[y
* stride
+ x
] = (LOWPASS(top
, x
+ y
+ 2) + LOWPASS(left
, x
+ y
+ 2)) >> 1;
312 static void intra_pred_down_right(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
315 for (y
= 0; y
< 8; y
++)
316 for (x
= 0; x
< 8; x
++)
318 d
[y
* stride
+ x
] = (left
[1] + 2 * top
[0] + top
[1] + 2) >> 2;
320 d
[y
* stride
+ x
] = LOWPASS(top
, x
- y
);
322 d
[y
* stride
+ x
] = LOWPASS(left
, y
- x
);
325 static void intra_pred_lp_left(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
328 for (y
= 0; y
< 8; y
++)
329 for (x
= 0; x
< 8; x
++)
330 d
[y
* stride
+ x
] = LOWPASS(left
, y
+ 1);
333 static void intra_pred_lp_top(uint8_t *d
,uint8_t *top
,uint8_t *left
,int stride
)
336 for (y
= 0; y
< 8; y
++)
337 for (x
= 0; x
< 8; x
++)
338 d
[y
* stride
+ x
] = LOWPASS(top
, x
+ 1);
343 static inline void modify_pred(const int8_t *mod_table
, int *mode
)
345 *mode
= mod_table
[*mode
];
347 av_log(NULL
, AV_LOG_ERROR
, "Illegal intra prediction mode\n");
352 void ff_cavs_modify_mb_i(AVSContext
*h
, int *pred_mode_uv
)
354 /* save pred modes before they get modified */
355 h
->pred_mode_Y
[3] = h
->pred_mode_Y
[5];
356 h
->pred_mode_Y
[6] = h
->pred_mode_Y
[8];
357 h
->top_pred_Y
[h
->mbx
* 2 + 0] = h
->pred_mode_Y
[7];
358 h
->top_pred_Y
[h
->mbx
* 2 + 1] = h
->pred_mode_Y
[8];
360 /* modify pred modes according to availability of neighbour samples */
361 if (!(h
->flags
& A_AVAIL
)) {
362 modify_pred(left_modifier_l
, &h
->pred_mode_Y
[4]);
363 modify_pred(left_modifier_l
, &h
->pred_mode_Y
[7]);
364 modify_pred(left_modifier_c
, pred_mode_uv
);
366 if (!(h
->flags
& B_AVAIL
)) {
367 modify_pred(top_modifier_l
, &h
->pred_mode_Y
[4]);
368 modify_pred(top_modifier_l
, &h
->pred_mode_Y
[5]);
369 modify_pred(top_modifier_c
, pred_mode_uv
);
373 /*****************************************************************************
375 * motion compensation
377 ****************************************************************************/
379 static inline void mc_dir_part(AVSContext
*h
, AVFrame
*pic
,
380 int chroma_height
,int delta
,int list
,uint8_t *dest_y
,
381 uint8_t *dest_cb
,uint8_t *dest_cr
,int src_x_offset
,
382 int src_y_offset
,qpel_mc_func
*qpix_op
,
383 h264_chroma_mc_func chroma_op
,cavs_vector
*mv
)
385 const int mx
= mv
->x
+ src_x_offset
*8;
386 const int my
= mv
->y
+ src_y_offset
*8;
387 const int luma_xy
= (mx
&3) + ((my
&3)<<2);
388 uint8_t * src_y
= pic
->data
[0] + (mx
>> 2) + (my
>> 2) * h
->l_stride
;
389 uint8_t * src_cb
= pic
->data
[1] + (mx
>> 3) + (my
>> 3) * h
->c_stride
;
390 uint8_t * src_cr
= pic
->data
[2] + (mx
>> 3) + (my
>> 3) * h
->c_stride
;
392 int extra_height
= extra_width
;
394 const int full_mx
= mx
>>2;
395 const int full_my
= my
>>2;
396 const int pic_width
= 16*h
->mb_width
;
397 const int pic_height
= 16*h
->mb_height
;
401 if(mx
&7) extra_width
-= 3;
402 if(my
&7) extra_height
-= 3;
404 if( full_mx
< 0-extra_width
405 || full_my
< 0-extra_height
406 || full_mx
+ 16/*FIXME*/ > pic_width
+ extra_width
407 || full_my
+ 16/*FIXME*/ > pic_height
+ extra_height
){
408 h
->vdsp
.emulated_edge_mc(h
->edge_emu_buffer
, src_y
- 2 - 2*h
->l_stride
, h
->l_stride
,
409 16+5, 16+5/*FIXME*/, full_mx
-2, full_my
-2, pic_width
, pic_height
);
410 src_y
= h
->edge_emu_buffer
+ 2 + 2*h
->l_stride
;
414 qpix_op
[luma_xy
](dest_y
, src_y
, h
->l_stride
); //FIXME try variable height perhaps?
417 h
->vdsp
.emulated_edge_mc(h
->edge_emu_buffer
, src_cb
, h
->c_stride
,
418 9, 9/*FIXME*/, (mx
>>3), (my
>>3), pic_width
>>1, pic_height
>>1);
419 src_cb
= h
->edge_emu_buffer
;
421 chroma_op(dest_cb
, src_cb
, h
->c_stride
, chroma_height
, mx
&7, my
&7);
424 h
->vdsp
.emulated_edge_mc(h
->edge_emu_buffer
, src_cr
, h
->c_stride
,
425 9, 9/*FIXME*/, (mx
>>3), (my
>>3), pic_width
>>1, pic_height
>>1);
426 src_cr
= h
->edge_emu_buffer
;
428 chroma_op(dest_cr
, src_cr
, h
->c_stride
, chroma_height
, mx
&7, my
&7);
431 static inline void mc_part_std(AVSContext
*h
,int chroma_height
,int delta
,
432 uint8_t *dest_y
,uint8_t *dest_cb
,uint8_t *dest_cr
,
433 int x_offset
, int y_offset
,qpel_mc_func
*qpix_put
,
434 h264_chroma_mc_func chroma_put
,qpel_mc_func
*qpix_avg
,
435 h264_chroma_mc_func chroma_avg
, cavs_vector
*mv
)
437 qpel_mc_func
*qpix_op
= qpix_put
;
438 h264_chroma_mc_func chroma_op
= chroma_put
;
440 dest_y
+= 2*x_offset
+ 2*y_offset
*h
->l_stride
;
441 dest_cb
+= x_offset
+ y_offset
*h
->c_stride
;
442 dest_cr
+= x_offset
+ y_offset
*h
->c_stride
;
443 x_offset
+= 8*h
->mbx
;
444 y_offset
+= 8*h
->mby
;
447 AVFrame
*ref
= h
->DPB
[mv
->ref
].f
;
448 mc_dir_part(h
, ref
, chroma_height
, delta
, 0,
449 dest_y
, dest_cb
, dest_cr
, x_offset
, y_offset
,
450 qpix_op
, chroma_op
, mv
);
453 chroma_op
= chroma_avg
;
456 if((mv
+MV_BWD_OFFS
)->ref
>= 0){
457 AVFrame
*ref
= h
->DPB
[0].f
;
458 mc_dir_part(h
, ref
, chroma_height
, delta
, 1,
459 dest_y
, dest_cb
, dest_cr
, x_offset
, y_offset
,
460 qpix_op
, chroma_op
, mv
+MV_BWD_OFFS
);
464 void ff_cavs_inter(AVSContext
*h
, enum cavs_mb mb_type
) {
465 if(ff_cavs_partition_flags
[mb_type
] == 0){ // 16x16
466 mc_part_std(h
, 8, 0, h
->cy
, h
->cu
, h
->cv
, 0, 0,
467 h
->cdsp
.put_cavs_qpel_pixels_tab
[0],
468 h
->h264chroma
.put_h264_chroma_pixels_tab
[0],
469 h
->cdsp
.avg_cavs_qpel_pixels_tab
[0],
470 h
->h264chroma
.avg_h264_chroma_pixels_tab
[0],
473 mc_part_std(h
, 4, 0, h
->cy
, h
->cu
, h
->cv
, 0, 0,
474 h
->cdsp
.put_cavs_qpel_pixels_tab
[1],
475 h
->h264chroma
.put_h264_chroma_pixels_tab
[1],
476 h
->cdsp
.avg_cavs_qpel_pixels_tab
[1],
477 h
->h264chroma
.avg_h264_chroma_pixels_tab
[1],
479 mc_part_std(h
, 4, 0, h
->cy
, h
->cu
, h
->cv
, 4, 0,
480 h
->cdsp
.put_cavs_qpel_pixels_tab
[1],
481 h
->h264chroma
.put_h264_chroma_pixels_tab
[1],
482 h
->cdsp
.avg_cavs_qpel_pixels_tab
[1],
483 h
->h264chroma
.avg_h264_chroma_pixels_tab
[1],
485 mc_part_std(h
, 4, 0, h
->cy
, h
->cu
, h
->cv
, 0, 4,
486 h
->cdsp
.put_cavs_qpel_pixels_tab
[1],
487 h
->h264chroma
.put_h264_chroma_pixels_tab
[1],
488 h
->cdsp
.avg_cavs_qpel_pixels_tab
[1],
489 h
->h264chroma
.avg_h264_chroma_pixels_tab
[1],
491 mc_part_std(h
, 4, 0, h
->cy
, h
->cu
, h
->cv
, 4, 4,
492 h
->cdsp
.put_cavs_qpel_pixels_tab
[1],
493 h
->h264chroma
.put_h264_chroma_pixels_tab
[1],
494 h
->cdsp
.avg_cavs_qpel_pixels_tab
[1],
495 h
->h264chroma
.avg_h264_chroma_pixels_tab
[1],
500 /*****************************************************************************
502 * motion vector prediction
504 ****************************************************************************/
506 static inline void scale_mv(AVSContext
*h
, int *d_x
, int *d_y
, cavs_vector
*src
, int distp
) {
507 int den
= h
->scale_den
[src
->ref
];
509 *d_x
= (src
->x
*distp
*den
+ 256 + (src
->x
>>31)) >> 9;
510 *d_y
= (src
->y
*distp
*den
+ 256 + (src
->y
>>31)) >> 9;
513 static inline void mv_pred_median(AVSContext
*h
, cavs_vector
*mvP
,
514 cavs_vector
*mvA
, cavs_vector
*mvB
, cavs_vector
*mvC
) {
515 int ax
, ay
, bx
, by
, cx
, cy
;
516 int len_ab
, len_bc
, len_ca
, len_mid
;
518 /* scale candidates according to their temporal span */
519 scale_mv(h
, &ax
, &ay
, mvA
, mvP
->dist
);
520 scale_mv(h
, &bx
, &by
, mvB
, mvP
->dist
);
521 scale_mv(h
, &cx
, &cy
, mvC
, mvP
->dist
);
522 /* find the geometrical median of the three candidates */
523 len_ab
= abs(ax
- bx
) + abs(ay
- by
);
524 len_bc
= abs(bx
- cx
) + abs(by
- cy
);
525 len_ca
= abs(cx
- ax
) + abs(cy
- ay
);
526 len_mid
= mid_pred(len_ab
, len_bc
, len_ca
);
527 if(len_mid
== len_ab
) {
530 } else if(len_mid
== len_bc
) {
539 void ff_cavs_mv(AVSContext
*h
, enum cavs_mv_loc nP
, enum cavs_mv_loc nC
,
540 enum cavs_mv_pred mode
, enum cavs_block size
, int ref
) {
541 cavs_vector
*mvP
= &h
->mv
[nP
];
542 cavs_vector
*mvA
= &h
->mv
[nP
-1];
543 cavs_vector
*mvB
= &h
->mv
[nP
-4];
544 cavs_vector
*mvC
= &h
->mv
[nC
];
545 const cavs_vector
*mvP2
= NULL
;
548 mvP
->dist
= h
->dist
[mvP
->ref
];
549 if(mvC
->ref
== NOT_AVAIL
)
550 mvC
= &h
->mv
[nP
-5]; // set to top-left (mvD)
551 if((mode
== MV_PRED_PSKIP
) &&
552 ((mvA
->ref
== NOT_AVAIL
) || (mvB
->ref
== NOT_AVAIL
) ||
553 ((mvA
->x
| mvA
->y
| mvA
->ref
) == 0) ||
554 ((mvB
->x
| mvB
->y
| mvB
->ref
) == 0) )) {
556 /* if there is only one suitable candidate, take it */
557 } else if((mvA
->ref
>= 0) && (mvB
->ref
< 0) && (mvC
->ref
< 0)) {
559 } else if((mvA
->ref
< 0) && (mvB
->ref
>= 0) && (mvC
->ref
< 0)) {
561 } else if((mvA
->ref
< 0) && (mvB
->ref
< 0) && (mvC
->ref
>= 0)) {
563 } else if(mode
== MV_PRED_LEFT
&& mvA
->ref
== ref
){
565 } else if(mode
== MV_PRED_TOP
&& mvB
->ref
== ref
){
567 } else if(mode
== MV_PRED_TOPRIGHT
&& mvC
->ref
== ref
){
574 mv_pred_median(h
, mvP
, mvA
, mvB
, mvC
);
576 if(mode
< MV_PRED_PSKIP
) {
577 mvP
->x
+= get_se_golomb(&h
->gb
);
578 mvP
->y
+= get_se_golomb(&h
->gb
);
583 /*****************************************************************************
587 ****************************************************************************/
590 * initialise predictors for motion vectors and intra prediction
592 void ff_cavs_init_mb(AVSContext
*h
) {
595 /* copy predictors from top line (MB B and C) into cache */
597 h
->mv
[MV_FWD_B2
+i
] = h
->top_mv
[0][h
->mbx
*2+i
];
598 h
->mv
[MV_BWD_B2
+i
] = h
->top_mv
[1][h
->mbx
*2+i
];
600 h
->pred_mode_Y
[1] = h
->top_pred_Y
[h
->mbx
*2+0];
601 h
->pred_mode_Y
[2] = h
->top_pred_Y
[h
->mbx
*2+1];
602 /* clear top predictors if MB B is not available */
603 if(!(h
->flags
& B_AVAIL
)) {
604 h
->mv
[MV_FWD_B2
] = un_mv
;
605 h
->mv
[MV_FWD_B3
] = un_mv
;
606 h
->mv
[MV_BWD_B2
] = un_mv
;
607 h
->mv
[MV_BWD_B3
] = un_mv
;
608 h
->pred_mode_Y
[1] = h
->pred_mode_Y
[2] = NOT_AVAIL
;
609 h
->flags
&= ~(C_AVAIL
|D_AVAIL
);
613 if(h
->mbx
== h
->mb_width
-1) //MB C not available
614 h
->flags
&= ~C_AVAIL
;
615 /* clear top-right predictors if MB C is not available */
616 if(!(h
->flags
& C_AVAIL
)) {
617 h
->mv
[MV_FWD_C2
] = un_mv
;
618 h
->mv
[MV_BWD_C2
] = un_mv
;
620 /* clear top-left predictors if MB D is not available */
621 if(!(h
->flags
& D_AVAIL
)) {
622 h
->mv
[MV_FWD_D3
] = un_mv
;
623 h
->mv
[MV_BWD_D3
] = un_mv
;
628 * save predictors for later macroblocks and increase
630 * @return 0 if end of frame is reached, 1 otherwise
632 int ff_cavs_next_mb(AVSContext
*h
) {
639 /* copy mvs as predictors to the left */
641 h
->mv
[i
] = h
->mv
[i
+2];
642 /* copy bottom mvs from cache to top line */
643 h
->top_mv
[0][h
->mbx
*2+0] = h
->mv
[MV_FWD_X2
];
644 h
->top_mv
[0][h
->mbx
*2+1] = h
->mv
[MV_FWD_X3
];
645 h
->top_mv
[1][h
->mbx
*2+0] = h
->mv
[MV_BWD_X2
];
646 h
->top_mv
[1][h
->mbx
*2+1] = h
->mv
[MV_BWD_X3
];
647 /* next MB address */
650 if(h
->mbx
== h
->mb_width
) { //new mb line
651 h
->flags
= B_AVAIL
|C_AVAIL
;
652 /* clear left pred_modes */
653 h
->pred_mode_Y
[3] = h
->pred_mode_Y
[6] = NOT_AVAIL
;
654 /* clear left mv predictors */
659 /* re-calculate sample pointers */
660 h
->cy
= h
->cur
.f
->data
[0] + h
->mby
* 16 * h
->l_stride
;
661 h
->cu
= h
->cur
.f
->data
[1] + h
->mby
* 8 * h
->c_stride
;
662 h
->cv
= h
->cur
.f
->data
[2] + h
->mby
* 8 * h
->c_stride
;
663 if(h
->mby
== h
->mb_height
) { //frame end
670 /*****************************************************************************
674 ****************************************************************************/
676 void ff_cavs_init_pic(AVSContext
*h
) {
679 /* clear some predictors */
682 h
->mv
[MV_BWD_X0
] = ff_cavs_dir_mv
;
683 set_mvs(&h
->mv
[MV_BWD_X0
], BLK_16X16
);
684 h
->mv
[MV_FWD_X0
] = ff_cavs_dir_mv
;
685 set_mvs(&h
->mv
[MV_FWD_X0
], BLK_16X16
);
686 h
->pred_mode_Y
[3] = h
->pred_mode_Y
[6] = NOT_AVAIL
;
687 h
->cy
= h
->cur
.f
->data
[0];
688 h
->cu
= h
->cur
.f
->data
[1];
689 h
->cv
= h
->cur
.f
->data
[2];
690 h
->l_stride
= h
->cur
.f
->linesize
[0];
691 h
->c_stride
= h
->cur
.f
->linesize
[1];
692 h
->luma_scan
[2] = 8*h
->l_stride
;
693 h
->luma_scan
[3] = 8*h
->l_stride
+8;
694 h
->mbx
= h
->mby
= h
->mbidx
= 0;
698 /*****************************************************************************
700 * headers and interface
702 ****************************************************************************/
705 * some predictions require data from the top-neighbouring macroblock.
706 * this data has to be stored for one complete row of macroblocks
707 * and this storage space is allocated here
709 void ff_cavs_init_top_lines(AVSContext
*h
) {
710 /* alloc top line of predictors */
711 h
->top_qp
= av_malloc( h
->mb_width
);
712 h
->top_mv
[0] = av_malloc((h
->mb_width
*2+1)*sizeof(cavs_vector
));
713 h
->top_mv
[1] = av_malloc((h
->mb_width
*2+1)*sizeof(cavs_vector
));
714 h
->top_pred_Y
= av_malloc( h
->mb_width
*2*sizeof(*h
->top_pred_Y
));
715 h
->top_border_y
= av_malloc((h
->mb_width
+1)*16);
716 h
->top_border_u
= av_malloc( h
->mb_width
* 10);
717 h
->top_border_v
= av_malloc( h
->mb_width
* 10);
719 /* alloc space for co-located MVs and types */
720 h
->col_mv
= av_malloc( h
->mb_width
*h
->mb_height
*4*sizeof(cavs_vector
));
721 h
->col_type_base
= av_malloc(h
->mb_width
*h
->mb_height
);
722 h
->block
= av_mallocz(64*sizeof(int16_t));
725 av_cold
int ff_cavs_init(AVCodecContext
*avctx
) {
726 AVSContext
*h
= avctx
->priv_data
;
728 ff_dsputil_init(&h
->dsp
, avctx
);
729 ff_h264chroma_init(&h
->h264chroma
, 8);
730 ff_videodsp_init(&h
->vdsp
, 8);
731 ff_cavsdsp_init(&h
->cdsp
, avctx
);
732 ff_init_scantable_permutation(h
->dsp
.idct_permutation
,
734 ff_init_scantable(h
->dsp
.idct_permutation
, &h
->scantable
, ff_zigzag_direct
);
737 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
739 h
->cur
.f
= avcodec_alloc_frame();
740 h
->DPB
[0].f
= avcodec_alloc_frame();
741 h
->DPB
[1].f
= avcodec_alloc_frame();
742 if (!h
->cur
.f
|| !h
->DPB
[0].f
|| !h
->DPB
[1].f
) {
744 return AVERROR(ENOMEM
);
749 h
->intra_pred_l
[ INTRA_L_VERT
] = intra_pred_vert
;
750 h
->intra_pred_l
[ INTRA_L_HORIZ
] = intra_pred_horiz
;
751 h
->intra_pred_l
[ INTRA_L_LP
] = intra_pred_lp
;
752 h
->intra_pred_l
[ INTRA_L_DOWN_LEFT
] = intra_pred_down_left
;
753 h
->intra_pred_l
[INTRA_L_DOWN_RIGHT
] = intra_pred_down_right
;
754 h
->intra_pred_l
[ INTRA_L_LP_LEFT
] = intra_pred_lp_left
;
755 h
->intra_pred_l
[ INTRA_L_LP_TOP
] = intra_pred_lp_top
;
756 h
->intra_pred_l
[ INTRA_L_DC_128
] = intra_pred_dc_128
;
757 h
->intra_pred_c
[ INTRA_C_LP
] = intra_pred_lp
;
758 h
->intra_pred_c
[ INTRA_C_HORIZ
] = intra_pred_horiz
;
759 h
->intra_pred_c
[ INTRA_C_VERT
] = intra_pred_vert
;
760 h
->intra_pred_c
[ INTRA_C_PLANE
] = intra_pred_plane
;
761 h
->intra_pred_c
[ INTRA_C_LP_LEFT
] = intra_pred_lp_left
;
762 h
->intra_pred_c
[ INTRA_C_LP_TOP
] = intra_pred_lp_top
;
763 h
->intra_pred_c
[ INTRA_C_DC_128
] = intra_pred_dc_128
;
769 av_cold
int ff_cavs_end(AVCodecContext
*avctx
) {
770 AVSContext
*h
= avctx
->priv_data
;
772 if (h
->cur
.f
->data
[0])
773 avctx
->release_buffer(avctx
, h
->cur
.f
);
774 if (h
->DPB
[0].f
->data
[0])
775 avctx
->release_buffer(avctx
, h
->DPB
[0].f
);
776 if (h
->DPB
[1].f
->data
[0])
777 avctx
->release_buffer(avctx
, h
->DPB
[1].f
);
778 avcodec_free_frame(&h
->cur
.f
);
779 avcodec_free_frame(&h
->DPB
[0].f
);
780 avcodec_free_frame(&h
->DPB
[1].f
);
783 av_free(h
->top_mv
[0]);
784 av_free(h
->top_mv
[1]);
785 av_free(h
->top_pred_Y
);
786 av_free(h
->top_border_y
);
787 av_free(h
->top_border_u
);
788 av_free(h
->top_border_v
);
790 av_free(h
->col_type_base
);
792 av_freep(&h
->edge_emu_buffer
);