Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Chinese AVS video (AVS1-P2, JiZhun profile) decoder.
  3.  * Copyright (c) 2006  Stefan Gehrer <stefan.gehrer@gmx.de>
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  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.
  11.  *
  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.
  16.  *
  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
  20.  */
  21.  
  22. /**
  23.  * @file
  24.  * Chinese AVS video (AVS1-P2, JiZhun profile) decoder
  25.  * @author Stefan Gehrer <stefan.gehrer@gmx.de>
  26.  */
  27.  
  28. #include "avcodec.h"
  29. #include "get_bits.h"
  30. #include "golomb.h"
  31. #include "h264chroma.h"
  32. #include "mathops.h"
  33. #include "cavs.h"
  34.  
  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
  40. };
  41.  
  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
  47. };
  48.  
  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
  54. };
  55.  
  56. /** mark block as unavailable, i.e. out of picture
  57.  *  or not yet decoded */
  58. static const cavs_vector un_mv = { 0, 0, 1, NOT_AVAIL };
  59.  
  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 };
  64.  
  65. /*****************************************************************************
  66.  *
  67.  * in-loop deblocking filter
  68.  *
  69.  ****************************************************************************/
  70.  
  71. static inline int get_bs(cavs_vector *mvP, cavs_vector *mvQ, int b)
  72. {
  73.     if ((mvP->ref == REF_INTRA) || (mvQ->ref == REF_INTRA))
  74.         return 2;
  75.     if ((abs(mvP->x - mvQ->x) >= 4) || (abs(mvP->y - mvQ->y) >= 4))
  76.         return 1;
  77.     if (b) {
  78.         mvP += MV_BWD_OFFS;
  79.         mvQ += MV_BWD_OFFS;
  80.         if ((abs(mvP->x - mvQ->x) >= 4) || (abs(mvP->y - mvQ->y) >= 4))
  81.             return 1;
  82.     } else {
  83.         if (mvP->ref != mvQ->ref)
  84.             return 1;
  85.     }
  86.     return 0;
  87. }
  88.  
  89. #define SET_PARAMS                                                \
  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)];
  93.  
  94. /**
  95.  * in-loop deblocking filter for a single macroblock
  96.  *
  97.  * boundary strength (bs) mapping:
  98.  *
  99.  * --4---5--
  100.  * 0   2   |
  101.  * | 6 | 7 |
  102.  * 1   3   |
  103.  * ---------
  104.  *
  105.  */
  106. void ff_cavs_filter(AVSContext *h, enum cavs_mb mb_type)
  107. {
  108.     uint8_t bs[8];
  109.     int qp_avg, alpha, beta, tc;
  110.     int i;
  111.  
  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);
  124.     }
  125.     if (!h->loop_filter_disable) {
  126.         /* determine bs */
  127.         if (mb_type == I_8X8)
  128.             memset(bs, 2, 8);
  129.         else {
  130.             memset(bs, 0, 8);
  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);
  134.             }
  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);
  138.             }
  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);
  143.         }
  144.         if (AV_RN64(bs)) {
  145.             if (h->flags & A_AVAIL) {
  146.                 qp_avg = (h->qp + h->left_qp + 1) >> 1;
  147.                 SET_PARAMS;
  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]);
  151.             }
  152.             qp_avg = h->qp;
  153.             SET_PARAMS;
  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]);
  156.  
  157.             if (h->flags & B_AVAIL) {
  158.                 qp_avg = (h->qp + h->top_qp[h->mbx] + 1) >> 1;
  159.                 SET_PARAMS;
  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]);
  163.             }
  164.         }
  165.     }
  166.     h->left_qp        = h->qp;
  167.     h->top_qp[h->mbx] = h->qp;
  168. }
  169.  
  170. #undef SET_PARAMS
  171.  
  172. /*****************************************************************************
  173.  *
  174.  * spatial intra prediction
  175.  *
  176.  ****************************************************************************/
  177.  
  178. void ff_cavs_load_intra_pred_luma(AVSContext *h, uint8_t *top,
  179.                                   uint8_t **left, int block)
  180. {
  181.     int i;
  182.  
  183.     switch (block) {
  184.     case 0:
  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);
  189.         top[17] = top[16];
  190.         top[0]  = top[1];
  191.         if ((h->flags & A_AVAIL) && (h->flags & B_AVAIL))
  192.             h->left_border_y[0] = top[0] = h->topleft_border_y;
  193.         break;
  194.     case 1:
  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);
  203.         else
  204.             memset(&top[9], top[8], 9);
  205.         top[17] = top[16];
  206.         top[0]  = top[1];
  207.         if (h->flags & B_AVAIL)
  208.             h->intern_border_y[0] = top[0] = h->top_border_y[h->mbx * 16 + 7];
  209.         break;
  210.     case 2:
  211.         *left = &h->left_border_y[8];
  212.         memcpy(&top[1], h->cy + 7 * h->l_stride, 16);
  213.         top[17] = top[16];
  214.         top[0]  = top[1];
  215.         if (h->flags & A_AVAIL)
  216.             top[0] = h->left_border_y[8];
  217.         break;
  218.     case 3:
  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);
  225.         break;
  226.     }
  227. }
  228.  
  229. void ff_cavs_load_intra_pred_chroma(AVSContext *h)
  230. {
  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;
  239.     } else {
  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];
  244.     }
  245. }
  246.  
  247. static void intra_pred_vert(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  248. {
  249.     int y;
  250.     uint64_t a = AV_RN64(&top[1]);
  251.     for (y = 0; y < 8; y++)
  252.         *((uint64_t *)(d + y * stride)) = a;
  253. }
  254.  
  255. static void intra_pred_horiz(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  256. {
  257.     int y;
  258.     uint64_t a;
  259.     for (y = 0; y < 8; y++) {
  260.         a = left[y + 1] * 0x0101010101010101ULL;
  261.         *((uint64_t *)(d + y * stride)) = a;
  262.     }
  263. }
  264.  
  265. static void intra_pred_dc_128(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  266. {
  267.     int y;
  268.     uint64_t a = 0x8080808080808080ULL;
  269.     for (y = 0; y < 8; y++)
  270.         *((uint64_t *)(d + y * stride)) = a;
  271. }
  272.  
  273. static void intra_pred_plane(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  274. {
  275.     int x, y, ia;
  276.     int ih = 0;
  277.     int iv = 0;
  278.     const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
  279.  
  280.     for (x = 0; x < 4; x++) {
  281.         ih += (x + 1) *  (top[5 + x] -  top[3 - x]);
  282.         iv += (x + 1) * (left[5 + x] - left[3 - x]);
  283.     }
  284.     ia = (top[8] + left[8]) << 4;
  285.     ih = (17 * ih + 16) >> 5;
  286.     iv = (17 * iv + 16) >> 5;
  287.     for (y = 0; y < 8; y++)
  288.         for (x = 0; x < 8; x++)
  289.             d[y * stride + x] = cm[(ia + (x - 3) * ih + (y - 3) * iv + 16) >> 5];
  290. }
  291.  
  292. #define LOWPASS(ARRAY, INDEX)                                           \
  293.     ((ARRAY[(INDEX) - 1] + 2 * ARRAY[(INDEX)] + ARRAY[(INDEX) + 1] + 2) >> 2)
  294.  
  295. static void intra_pred_lp(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  296. {
  297.     int x, y;
  298.     for (y = 0; y < 8; y++)
  299.         for (x = 0; x < 8; x++)
  300.             d[y * stride + x] = (LOWPASS(top, x + 1) + LOWPASS(left, y + 1)) >> 1;
  301. }
  302.  
  303. static void intra_pred_down_left(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  304. {
  305.     int x, y;
  306.     for (y = 0; y < 8; y++)
  307.         for (x = 0; x < 8; x++)
  308.             d[y * stride + x] = (LOWPASS(top, x + y + 2) + LOWPASS(left, x + y + 2)) >> 1;
  309. }
  310.  
  311. static void intra_pred_down_right(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  312. {
  313.     int x, y;
  314.     for (y = 0; y < 8; y++)
  315.         for (x = 0; x < 8; x++)
  316.             if (x == y)
  317.                 d[y * stride + x] = (left[1] + 2 * top[0] + top[1] + 2) >> 2;
  318.             else if (x > y)
  319.                 d[y * stride + x] = LOWPASS(top, x - y);
  320.             else
  321.                 d[y * stride + x] = LOWPASS(left, y - x);
  322. }
  323.  
  324. static void intra_pred_lp_left(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  325. {
  326.     int x, y;
  327.     for (y = 0; y < 8; y++)
  328.         for (x = 0; x < 8; x++)
  329.             d[y * stride + x] = LOWPASS(left, y + 1);
  330. }
  331.  
  332. static void intra_pred_lp_top(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
  333. {
  334.     int x, y;
  335.     for (y = 0; y < 8; y++)
  336.         for (x = 0; x < 8; x++)
  337.             d[y * stride + x] = LOWPASS(top, x + 1);
  338. }
  339.  
  340. #undef LOWPASS
  341.  
  342. static inline void modify_pred(const int8_t *mod_table, int *mode)
  343. {
  344.     *mode = mod_table[*mode];
  345.     if (*mode < 0) {
  346.         av_log(NULL, AV_LOG_ERROR, "Illegal intra prediction mode\n");
  347.         *mode = 0;
  348.     }
  349. }
  350.  
  351. void ff_cavs_modify_mb_i(AVSContext *h, int *pred_mode_uv)
  352. {
  353.     /* save pred modes before they get modified */
  354.     h->pred_mode_Y[3]             = h->pred_mode_Y[5];
  355.     h->pred_mode_Y[6]             = h->pred_mode_Y[8];
  356.     h->top_pred_Y[h->mbx * 2 + 0] = h->pred_mode_Y[7];
  357.     h->top_pred_Y[h->mbx * 2 + 1] = h->pred_mode_Y[8];
  358.  
  359.     /* modify pred modes according to availability of neighbour samples */
  360.     if (!(h->flags & A_AVAIL)) {
  361.         modify_pred(left_modifier_l, &h->pred_mode_Y[4]);
  362.         modify_pred(left_modifier_l, &h->pred_mode_Y[7]);
  363.         modify_pred(left_modifier_c, pred_mode_uv);
  364.     }
  365.     if (!(h->flags & B_AVAIL)) {
  366.         modify_pred(top_modifier_l, &h->pred_mode_Y[4]);
  367.         modify_pred(top_modifier_l, &h->pred_mode_Y[5]);
  368.         modify_pred(top_modifier_c, pred_mode_uv);
  369.     }
  370. }
  371.  
  372. /*****************************************************************************
  373.  *
  374.  * motion compensation
  375.  *
  376.  ****************************************************************************/
  377.  
  378. static inline void mc_dir_part(AVSContext *h, AVFrame *pic, int chroma_height,
  379.                                int delta, int list, uint8_t *dest_y,
  380.                                uint8_t *dest_cb, uint8_t *dest_cr,
  381.                                int src_x_offset, int src_y_offset,
  382.                                qpel_mc_func *qpix_op,
  383.                                h264_chroma_mc_func chroma_op, cavs_vector *mv)
  384. {
  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;
  391.     int extra_width      = 0;
  392.     int extra_height     = extra_width;
  393.     const int full_mx    = mx >> 2;
  394.     const int full_my    = my >> 2;
  395.     const int pic_width  = 16 * h->mb_width;
  396.     const int pic_height = 16 * h->mb_height;
  397.     int emu = 0;
  398.  
  399.     if (!pic->data[0])
  400.         return;
  401.     if (mx & 7)
  402.         extra_width  -= 3;
  403.     if (my & 7)
  404.         extra_height -= 3;
  405.  
  406.     if (full_mx < 0 - extra_width ||
  407.         full_my < 0 - extra_height ||
  408.         full_mx + 16 /* FIXME */ > pic_width + extra_width ||
  409.         full_my + 16 /* FIXME */ > pic_height + extra_height) {
  410.         h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->l_stride,
  411.                                  src_y - 2 - 2 * h->l_stride, h->l_stride,
  412.                                  16 + 5, 16 + 5 /* FIXME */,
  413.                                  full_mx - 2, full_my - 2,
  414.                                  pic_width, pic_height);
  415.         src_y = h->edge_emu_buffer + 2 + 2 * h->l_stride;
  416.         emu   = 1;
  417.     }
  418.  
  419.     // FIXME try variable height perhaps?
  420.     qpix_op[luma_xy](dest_y, src_y, h->l_stride);
  421.  
  422.     if (emu) {
  423.         h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->c_stride, src_cb,
  424.                                  h->c_stride,
  425.                                  9, 9 /* FIXME */,
  426.                                  mx >> 3, my >> 3,
  427.                                  pic_width >> 1, pic_height >> 1);
  428.         src_cb = h->edge_emu_buffer;
  429.     }
  430.     chroma_op(dest_cb, src_cb, h->c_stride, chroma_height, mx & 7, my & 7);
  431.  
  432.     if (emu) {
  433.         h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->c_stride, src_cr,
  434.                                  h->c_stride,
  435.                                  9, 9 /* FIXME */,
  436.                                  mx >> 3, my >> 3,
  437.                                  pic_width >> 1, pic_height >> 1);
  438.         src_cr = h->edge_emu_buffer;
  439.     }
  440.     chroma_op(dest_cr, src_cr, h->c_stride, chroma_height, mx & 7, my & 7);
  441. }
  442.  
  443. static inline void mc_part_std(AVSContext *h, int chroma_height, int delta,
  444.                                uint8_t *dest_y,
  445.                                uint8_t *dest_cb,
  446.                                uint8_t *dest_cr,
  447.                                int x_offset, int y_offset,
  448.                                qpel_mc_func *qpix_put,
  449.                                h264_chroma_mc_func chroma_put,
  450.                                qpel_mc_func *qpix_avg,
  451.                                h264_chroma_mc_func chroma_avg,
  452.                                cavs_vector *mv)
  453. {
  454.     qpel_mc_func *qpix_op =  qpix_put;
  455.     h264_chroma_mc_func chroma_op = chroma_put;
  456.  
  457.     dest_y   += x_offset * 2 + y_offset * h->l_stride * 2;
  458.     dest_cb  += x_offset     + y_offset * h->c_stride;
  459.     dest_cr  += x_offset     + y_offset * h->c_stride;
  460.     x_offset += 8 * h->mbx;
  461.     y_offset += 8 * h->mby;
  462.  
  463.     if (mv->ref >= 0) {
  464.         AVFrame *ref = h->DPB[mv->ref].f;
  465.         mc_dir_part(h, ref, chroma_height, delta, 0,
  466.                     dest_y, dest_cb, dest_cr, x_offset, y_offset,
  467.                     qpix_op, chroma_op, mv);
  468.  
  469.         qpix_op   = qpix_avg;
  470.         chroma_op = chroma_avg;
  471.     }
  472.  
  473.     if ((mv + MV_BWD_OFFS)->ref >= 0) {
  474.         AVFrame *ref = h->DPB[0].f;
  475.         mc_dir_part(h, ref, chroma_height, delta, 1,
  476.                     dest_y, dest_cb, dest_cr, x_offset, y_offset,
  477.                     qpix_op, chroma_op, mv + MV_BWD_OFFS);
  478.     }
  479. }
  480.  
  481. void ff_cavs_inter(AVSContext *h, enum cavs_mb mb_type)
  482. {
  483.     if (ff_cavs_partition_flags[mb_type] == 0) { // 16x16
  484.         mc_part_std(h, 8, 0, h->cy, h->cu, h->cv, 0, 0,
  485.                     h->cdsp.put_cavs_qpel_pixels_tab[0],
  486.                     h->h264chroma.put_h264_chroma_pixels_tab[0],
  487.                     h->cdsp.avg_cavs_qpel_pixels_tab[0],
  488.                     h->h264chroma.avg_h264_chroma_pixels_tab[0],
  489.                     &h->mv[MV_FWD_X0]);
  490.     } else {
  491.         mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 0,
  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],
  496.                     &h->mv[MV_FWD_X0]);
  497.         mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 4, 0,
  498.                     h->cdsp.put_cavs_qpel_pixels_tab[1],
  499.                     h->h264chroma.put_h264_chroma_pixels_tab[1],
  500.                     h->cdsp.avg_cavs_qpel_pixels_tab[1],
  501.                     h->h264chroma.avg_h264_chroma_pixels_tab[1],
  502.                     &h->mv[MV_FWD_X1]);
  503.         mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 4,
  504.                     h->cdsp.put_cavs_qpel_pixels_tab[1],
  505.                     h->h264chroma.put_h264_chroma_pixels_tab[1],
  506.                     h->cdsp.avg_cavs_qpel_pixels_tab[1],
  507.                     h->h264chroma.avg_h264_chroma_pixels_tab[1],
  508.                     &h->mv[MV_FWD_X2]);
  509.         mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 4, 4,
  510.                     h->cdsp.put_cavs_qpel_pixels_tab[1],
  511.                     h->h264chroma.put_h264_chroma_pixels_tab[1],
  512.                     h->cdsp.avg_cavs_qpel_pixels_tab[1],
  513.                     h->h264chroma.avg_h264_chroma_pixels_tab[1],
  514.                     &h->mv[MV_FWD_X3]);
  515.     }
  516. }
  517.  
  518. /*****************************************************************************
  519.  *
  520.  * motion vector prediction
  521.  *
  522.  ****************************************************************************/
  523.  
  524. static inline void scale_mv(AVSContext *h, int *d_x, int *d_y,
  525.                             cavs_vector *src, int distp)
  526. {
  527.     int den = h->scale_den[src->ref];
  528.  
  529.     *d_x = (src->x * distp * den + 256 + (src->x >> 31)) >> 9;
  530.     *d_y = (src->y * distp * den + 256 + (src->y >> 31)) >> 9;
  531. }
  532.  
  533. static inline void mv_pred_median(AVSContext *h,
  534.                                   cavs_vector *mvP,
  535.                                   cavs_vector *mvA,
  536.                                   cavs_vector *mvB,
  537.                                   cavs_vector *mvC)
  538. {
  539.     int ax, ay, bx, by, cx, cy;
  540.     int len_ab, len_bc, len_ca, len_mid;
  541.  
  542.     /* scale candidates according to their temporal span */
  543.     scale_mv(h, &ax, &ay, mvA, mvP->dist);
  544.     scale_mv(h, &bx, &by, mvB, mvP->dist);
  545.     scale_mv(h, &cx, &cy, mvC, mvP->dist);
  546.     /* find the geometrical median of the three candidates */
  547.     len_ab  = abs(ax - bx) + abs(ay - by);
  548.     len_bc  = abs(bx - cx) + abs(by - cy);
  549.     len_ca  = abs(cx - ax) + abs(cy - ay);
  550.     len_mid = mid_pred(len_ab, len_bc, len_ca);
  551.     if (len_mid == len_ab) {
  552.         mvP->x = cx;
  553.         mvP->y = cy;
  554.     } else if (len_mid == len_bc) {
  555.         mvP->x = ax;
  556.         mvP->y = ay;
  557.     } else {
  558.         mvP->x = bx;
  559.         mvP->y = by;
  560.     }
  561. }
  562.  
  563. void ff_cavs_mv(AVSContext *h, enum cavs_mv_loc nP, enum cavs_mv_loc nC,
  564.                 enum cavs_mv_pred mode, enum cavs_block size, int ref)
  565. {
  566.     cavs_vector *mvP = &h->mv[nP];
  567.     cavs_vector *mvA = &h->mv[nP-1];
  568.     cavs_vector *mvB = &h->mv[nP-4];
  569.     cavs_vector *mvC = &h->mv[nC];
  570.     const cavs_vector *mvP2 = NULL;
  571.  
  572.     mvP->ref  = ref;
  573.     mvP->dist = h->dist[mvP->ref];
  574.     if (mvC->ref == NOT_AVAIL)
  575.         mvC = &h->mv[nP - 5];  // set to top-left (mvD)
  576.     if (mode == MV_PRED_PSKIP &&
  577.         (mvA->ref == NOT_AVAIL ||
  578.          mvB->ref == NOT_AVAIL ||
  579.          (mvA->x | mvA->y | mvA->ref) == 0 ||
  580.          (mvB->x | mvB->y | mvB->ref) == 0)) {
  581.         mvP2 = &un_mv;
  582.     /* if there is only one suitable candidate, take it */
  583.     } else if (mvA->ref >= 0 && mvB->ref < 0  && mvC->ref < 0) {
  584.         mvP2 = mvA;
  585.     } else if (mvA->ref < 0  && mvB->ref >= 0 && mvC->ref < 0) {
  586.         mvP2 = mvB;
  587.     } else if (mvA->ref < 0  && mvB->ref < 0  && mvC->ref >= 0) {
  588.         mvP2 = mvC;
  589.     } else if (mode == MV_PRED_LEFT     && mvA->ref == ref) {
  590.         mvP2 = mvA;
  591.     } else if (mode == MV_PRED_TOP      && mvB->ref == ref) {
  592.         mvP2 = mvB;
  593.     } else if (mode == MV_PRED_TOPRIGHT && mvC->ref == ref) {
  594.         mvP2 = mvC;
  595.     }
  596.     if (mvP2) {
  597.         mvP->x = mvP2->x;
  598.         mvP->y = mvP2->y;
  599.     } else
  600.         mv_pred_median(h, mvP, mvA, mvB, mvC);
  601.  
  602.     if (mode < MV_PRED_PSKIP) {
  603.         mvP->x += get_se_golomb(&h->gb);
  604.         mvP->y += get_se_golomb(&h->gb);
  605.     }
  606.     set_mvs(mvP, size);
  607. }
  608.  
  609. /*****************************************************************************
  610.  *
  611.  * macroblock level
  612.  *
  613.  ****************************************************************************/
  614.  
  615. /**
  616.  * initialise predictors for motion vectors and intra prediction
  617.  */
  618. void ff_cavs_init_mb(AVSContext *h)
  619. {
  620.     int i;
  621.  
  622.     /* copy predictors from top line (MB B and C) into cache */
  623.     for (i = 0; i < 3; i++) {
  624.         h->mv[MV_FWD_B2 + i] = h->top_mv[0][h->mbx * 2 + i];
  625.         h->mv[MV_BWD_B2 + i] = h->top_mv[1][h->mbx * 2 + i];
  626.     }
  627.     h->pred_mode_Y[1] = h->top_pred_Y[h->mbx * 2 + 0];
  628.     h->pred_mode_Y[2] = h->top_pred_Y[h->mbx * 2 + 1];
  629.     /* clear top predictors if MB B is not available */
  630.     if (!(h->flags & B_AVAIL)) {
  631.         h->mv[MV_FWD_B2]  = un_mv;
  632.         h->mv[MV_FWD_B3]  = un_mv;
  633.         h->mv[MV_BWD_B2]  = un_mv;
  634.         h->mv[MV_BWD_B3]  = un_mv;
  635.         h->pred_mode_Y[1] = h->pred_mode_Y[2] = NOT_AVAIL;
  636.         h->flags         &= ~(C_AVAIL | D_AVAIL);
  637.     } else if (h->mbx) {
  638.         h->flags |= D_AVAIL;
  639.     }
  640.     if (h->mbx == h->mb_width - 1) // MB C not available
  641.         h->flags &= ~C_AVAIL;
  642.     /* clear top-right predictors if MB C is not available */
  643.     if (!(h->flags & C_AVAIL)) {
  644.         h->mv[MV_FWD_C2] = un_mv;
  645.         h->mv[MV_BWD_C2] = un_mv;
  646.     }
  647.     /* clear top-left predictors if MB D is not available */
  648.     if (!(h->flags & D_AVAIL)) {
  649.         h->mv[MV_FWD_D3] = un_mv;
  650.         h->mv[MV_BWD_D3] = un_mv;
  651.     }
  652. }
  653.  
  654. /**
  655.  * save predictors for later macroblocks and increase
  656.  * macroblock address
  657.  * @return 0 if end of frame is reached, 1 otherwise
  658.  */
  659. int ff_cavs_next_mb(AVSContext *h)
  660. {
  661.     int i;
  662.  
  663.     h->flags |= A_AVAIL;
  664.     h->cy    += 16;
  665.     h->cu    += 8;
  666.     h->cv    += 8;
  667.     /* copy mvs as predictors to the left */
  668.     for (i = 0; i <= 20; i += 4)
  669.         h->mv[i] = h->mv[i + 2];
  670.     /* copy bottom mvs from cache to top line */
  671.     h->top_mv[0][h->mbx * 2 + 0] = h->mv[MV_FWD_X2];
  672.     h->top_mv[0][h->mbx * 2 + 1] = h->mv[MV_FWD_X3];
  673.     h->top_mv[1][h->mbx * 2 + 0] = h->mv[MV_BWD_X2];
  674.     h->top_mv[1][h->mbx * 2 + 1] = h->mv[MV_BWD_X3];
  675.     /* next MB address */
  676.     h->mbidx++;
  677.     h->mbx++;
  678.     if (h->mbx == h->mb_width) { // New mb line
  679.         h->flags = B_AVAIL | C_AVAIL;
  680.         /* clear left pred_modes */
  681.         h->pred_mode_Y[3] = h->pred_mode_Y[6] = NOT_AVAIL;
  682.         /* clear left mv predictors */
  683.         for (i = 0; i <= 20; i += 4)
  684.             h->mv[i] = un_mv;
  685.         h->mbx = 0;
  686.         h->mby++;
  687.         /* re-calculate sample pointers */
  688.         h->cy = h->cur.f->data[0] + h->mby * 16 * h->l_stride;
  689.         h->cu = h->cur.f->data[1] + h->mby * 8 * h->c_stride;
  690.         h->cv = h->cur.f->data[2] + h->mby * 8 * h->c_stride;
  691.         if (h->mby == h->mb_height) { // Frame end
  692.             return 0;
  693.         }
  694.     }
  695.     return 1;
  696. }
  697.  
  698. /*****************************************************************************
  699.  *
  700.  * frame level
  701.  *
  702.  ****************************************************************************/
  703.  
  704. int ff_cavs_init_pic(AVSContext *h)
  705. {
  706.     int i;
  707.  
  708.     /* clear some predictors */
  709.     for (i = 0; i <= 20; i += 4)
  710.         h->mv[i] = un_mv;
  711.     h->mv[MV_BWD_X0] = ff_cavs_dir_mv;
  712.     set_mvs(&h->mv[MV_BWD_X0], BLK_16X16);
  713.     h->mv[MV_FWD_X0] = ff_cavs_dir_mv;
  714.     set_mvs(&h->mv[MV_FWD_X0], BLK_16X16);
  715.     h->pred_mode_Y[3] = h->pred_mode_Y[6] = NOT_AVAIL;
  716.     h->cy             = h->cur.f->data[0];
  717.     h->cu             = h->cur.f->data[1];
  718.     h->cv             = h->cur.f->data[2];
  719.     h->l_stride       = h->cur.f->linesize[0];
  720.     h->c_stride       = h->cur.f->linesize[1];
  721.     h->luma_scan[2]   = 8 * h->l_stride;
  722.     h->luma_scan[3]   = 8 * h->l_stride + 8;
  723.     h->mbx            = h->mby = h->mbidx = 0;
  724.     h->flags          = 0;
  725.  
  726.     return 0;
  727. }
  728.  
  729. /*****************************************************************************
  730.  *
  731.  * headers and interface
  732.  *
  733.  ****************************************************************************/
  734.  
  735. /**
  736.  * some predictions require data from the top-neighbouring macroblock.
  737.  * this data has to be stored for one complete row of macroblocks
  738.  * and this storage space is allocated here
  739.  */
  740. void ff_cavs_init_top_lines(AVSContext *h)
  741. {
  742.     /* alloc top line of predictors */
  743.     h->top_qp       = av_mallocz(h->mb_width);
  744.     h->top_mv[0]    = av_mallocz((h->mb_width * 2 + 1) * sizeof(cavs_vector));
  745.     h->top_mv[1]    = av_mallocz((h->mb_width * 2 + 1) * sizeof(cavs_vector));
  746.     h->top_pred_Y   = av_mallocz(h->mb_width * 2 * sizeof(*h->top_pred_Y));
  747.     h->top_border_y = av_mallocz((h->mb_width + 1) * 16);
  748.     h->top_border_u = av_mallocz(h->mb_width * 10);
  749.     h->top_border_v = av_mallocz(h->mb_width * 10);
  750.  
  751.     /* alloc space for co-located MVs and types */
  752.     h->col_mv        = av_mallocz(h->mb_width * h->mb_height * 4 *
  753.                                   sizeof(cavs_vector));
  754.     h->col_type_base = av_mallocz(h->mb_width * h->mb_height);
  755.     h->block         = av_mallocz(64 * sizeof(int16_t));
  756. }
  757.  
  758. av_cold int ff_cavs_init(AVCodecContext *avctx)
  759. {
  760.     AVSContext *h = avctx->priv_data;
  761.  
  762.     ff_dsputil_init(&h->dsp, avctx);
  763.     ff_h264chroma_init(&h->h264chroma, 8);
  764.     ff_videodsp_init(&h->vdsp, 8);
  765.     ff_cavsdsp_init(&h->cdsp, avctx);
  766.     ff_init_scantable_permutation(h->dsp.idct_permutation,
  767.                                   h->cdsp.idct_perm);
  768.     ff_init_scantable(h->dsp.idct_permutation, &h->scantable, ff_zigzag_direct);
  769.  
  770.     h->avctx       = avctx;
  771.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
  772.  
  773.     h->cur.f    = av_frame_alloc();
  774.     h->DPB[0].f = av_frame_alloc();
  775.     h->DPB[1].f = av_frame_alloc();
  776.     if (!h->cur.f || !h->DPB[0].f || !h->DPB[1].f) {
  777.         ff_cavs_end(avctx);
  778.         return AVERROR(ENOMEM);
  779.     }
  780.  
  781.     h->luma_scan[0]                     = 0;
  782.     h->luma_scan[1]                     = 8;
  783.     h->intra_pred_l[INTRA_L_VERT]       = intra_pred_vert;
  784.     h->intra_pred_l[INTRA_L_HORIZ]      = intra_pred_horiz;
  785.     h->intra_pred_l[INTRA_L_LP]         = intra_pred_lp;
  786.     h->intra_pred_l[INTRA_L_DOWN_LEFT]  = intra_pred_down_left;
  787.     h->intra_pred_l[INTRA_L_DOWN_RIGHT] = intra_pred_down_right;
  788.     h->intra_pred_l[INTRA_L_LP_LEFT]    = intra_pred_lp_left;
  789.     h->intra_pred_l[INTRA_L_LP_TOP]     = intra_pred_lp_top;
  790.     h->intra_pred_l[INTRA_L_DC_128]     = intra_pred_dc_128;
  791.     h->intra_pred_c[INTRA_C_LP]         = intra_pred_lp;
  792.     h->intra_pred_c[INTRA_C_HORIZ]      = intra_pred_horiz;
  793.     h->intra_pred_c[INTRA_C_VERT]       = intra_pred_vert;
  794.     h->intra_pred_c[INTRA_C_PLANE]      = intra_pred_plane;
  795.     h->intra_pred_c[INTRA_C_LP_LEFT]    = intra_pred_lp_left;
  796.     h->intra_pred_c[INTRA_C_LP_TOP]     = intra_pred_lp_top;
  797.     h->intra_pred_c[INTRA_C_DC_128]     = intra_pred_dc_128;
  798.     h->mv[7]                            = un_mv;
  799.     h->mv[19]                           = un_mv;
  800.     return 0;
  801. }
  802.  
  803. av_cold int ff_cavs_end(AVCodecContext *avctx)
  804. {
  805.     AVSContext *h = avctx->priv_data;
  806.  
  807.     av_frame_free(&h->cur.f);
  808.     av_frame_free(&h->DPB[0].f);
  809.     av_frame_free(&h->DPB[1].f);
  810.  
  811.     av_free(h->top_qp);
  812.     av_free(h->top_mv[0]);
  813.     av_free(h->top_mv[1]);
  814.     av_free(h->top_pred_Y);
  815.     av_free(h->top_border_y);
  816.     av_free(h->top_border_u);
  817.     av_free(h->top_border_v);
  818.     av_free(h->col_mv);
  819.     av_free(h->col_type_base);
  820.     av_free(h->block);
  821.     av_freep(&h->edge_emu_buffer);
  822.     return 0;
  823. }
  824.