开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
ratecontrol.c
资源名称：h264src.zip　[点击查看]
上传用户：sunbaby
上传日期：2013-05-31
资源大小：242k
文件大小：17k
源码类别：

mpeg/mp3

开发平台：

Visual C++

ratecontrol.c：源码内容
  1. /*****************************************************************************
  2. *
  3. *  T264 AVC CODEC
  4. *
  5. *  Copyright(C) 2004-2005 llcc <lcgate1@yahoo.com.cn>
  6. *               2004-2005 visionany <visionany@yahoo.com.cn>
  7. *
  8. *  This program is free software ; you can redistribute it and/or modify
  9. *  it under the terms of the GNU General Public License as published by
  10. *  the Free Software Foundation ; either version 2 of the License, or
  11. *  (at your option) any later version.
  12. *
  13. *  This program is distributed in the hope that it will be useful,
  14. *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
  15. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. *  GNU General Public License for more details.
  17. *
  18. *  You should have received a copy of the GNU General Public License
  19. *  along with this program ; if not, write to the Free Software
  20. *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21. *
  22. ****************************************************************************/
  24. #include "stdio.h"
  25. #include "stdlib.h"
  26. #include "T264.h"
  27. #include "ratecontrol.h"
  28. #include "math.h"
  29. #ifndef CHIP_DM642
  30. #include "memory.h"
  31. #endif
  33. typedef struct
  34. {
  35.     // frame numbers per gop
  36.     int32_t gop;
  37.     int32_t np;
  38.     int32_t nb;
  39.     int32_t qp_sum;
  40.     // the number in current gop, based on 0
  41.     int32_t p_no;
  42.     int32_t b_no;
  43.     // prev qp1, qp2
  44.     int32_t qp_p1;
  45.     int32_t qp_p2;
  46.     double deltap;
  47.     // fluid Flow Traffic Model
  48.     int32_t bc;
  49.     // linear Model
  50.     double a1;
  51.     double a2;
  52.     // model
  53.     double x1;
  54.     double x2;
  55.     double qp[20];
  56.     double rp[20];
  57.     double mad[20];
  58.     int32_t window_p;
  59.     int32_t mad_window_p;
  60.     // remaining bits in gop
  61.     int32_t gop_bits;
  62.     double tbl;
  63.     double gamma;
  64.     double beta;
  65.     double theta;
  66.     double wp;
  67.     double wb;
  68.     double AWp;
  69.     double AWb;
  70.     int32_t ideal_bits;
  71.     double mad_p;
  72. } T264_rc_t;
  74. void rc_init_seq(T264_t* t, T264_rc_t* rc);
  75. void rc_init_gop(T264_t* t, T264_rc_t* rc);
  76. void rc_init_pic(T264_t* t, T264_rc_t* rc);
  77. void rc_update_pic(T264_t* t, T264_rc_t* rc);
  78. // frame level
  79. void rc_update_qp(T264_t* t, T264_rc_t* rc);
  80. // quadratic model
  81. void rc_update_quad_model(T264_t* t, T264_rc_t* rc);
  83. void 
  84. rc_init_seq(T264_t* t, T264_rc_t* rc)
  85. {
  86.     double bpp, L1, L2, L3;
  88.     rc->gop = T264_MIN(t->param.idrframe, t->param.iframe);
  89.     rc->np = rc->gop / (1 + t->param.b_num) - 1;
  90.     rc->nb = rc->gop - rc->np - 1;
  91.     rc->bc = 0;
  92.     rc->a1 = 1.0;
  93.     rc->a2 = 0.0;
  94.     rc->x1 = t->param.bitrate;
  96.     if (rc->nb > 0)
  97.     {
  98.         rc->gamma = 0.25;
  99.         rc->beta = 0.9;
  100.         rc->theta = 1.3636;
  101.     }
  102.     else
  103.     {
  104.         rc->gamma = 0.5;
  105.         rc->beta = 0.75;
  106.     }
  108.     if (t->param.qp == 0)
  109.     {
  110.         bpp = ((double)t->param.bitrate) / (t->param.framerate * t->param.width * t->param.height);
  111.         if (t->param.width == 176)
  112.         {
  113.             L1 = 0.1;
  114.             L2 = 0.3;
  115.             L3 = 0.6;
  116.         }
  117.         else if (t->param.width == 352)
  118.         {
  119.             L1 = 0.2;
  120.             L2 = 0.6;
  121.             L3 = 1.2;
  122.         }
  123.         else
  124.         {
  125.             L1 = 0.6;
  126.             L2 = 1.4;
  127.             L3 = 2.4;
  128.         }
  130.         // first gop first i, p
  131.         if (bpp <= L1)
  132.         {
  133.             t->qp_y = 30;
  134.         }
  135.         else if (bpp <= L2)
  136.         {
  137.             t->qp_y = 25;
  138.         }
  139.         else if (bpp <= L3)
  140.         {
  141.             t->qp_y = 20;
  142.         }
  143.         else
  144.         {
  145.             t->qp_y = 10;
  146.         }
  147.     }
  148. }
  150. void 
  151. rc_init_gop(T264_t* t, T264_rc_t* rc)
  152. {
  153.     rc->gop_bits = (int32_t)(rc->gop * t->param.bitrate / (t->param.framerate) - rc->bc);
  154.     if (t->frame_id != 0)
  155.     {
  156.         // JVTH0014 say to do so
  157.         // t->qp_y = rc->qp_sum / rc->np + 8 * rc->bc / rc->gop_bits - T264_MIN(2, rc->gop / 15);
  158.         // JM does this way
  159.         t->qp_y = rc->qp_sum / rc->np - T264_MIN(2, rc->gop / 15);
  160.         if (rc->gop != 1)
  161.         {
  162.             if (t->qp_y > rc->qp_p2 - 2)
  163.                 t->qp_y --;
  164.             t->qp_y = clip3(t->qp_y, rc->qp_p2 - 2, rc->qp_p2 + 2);
  165.         }
  166.         t->qp_y = clip3(t->qp_y, t->param.min_qp, t->param.max_qp);
  167.     }
  169.     rc->qp_sum = 0;
  170.     rc->p_no = 0;
  171.     rc->b_no = 0;
  172.     rc->qp_p2 = t->qp_y;
  173. }
  175. void 
  176. rc_init_pic(T264_t* t, T264_rc_t* rc)
  177. {
  178.     int32_t f1, f2, f;
  180.     if (t->slice_type == SLICE_P)
  181.     {
  182.         if (rc->p_no > 0)
  183.         {
  184.             // Step 1.1 Determination of target buffer occupancy
  185.             if (rc->p_no == 1)
  186.             {
  187.                 rc->deltap = ((double)rc->bc) / (double)(rc->np - 1);
  188.                 rc->tbl = rc->bc;
  189.                 rc->AWp = rc->wp;
  190.                 rc->AWb = rc->wb;
  191.             }
  192.             else if (rc->p_no < 8)
  193.             {
  194.                 rc->AWp = rc->wp * (rc->p_no - 1) / (rc->p_no) + rc->AWp/ (rc->p_no);
  195.             }
  196.             else
  197.             {
  198.                 rc->AWp = rc->wp / 8 + 7 * rc->AWp / 8;
  199.             }
  200.             
  201.             rc->tbl -= rc->deltap;
  202.             if (t->param.b_num > 0)
  203.             {
  204.                 rc->tbl += rc->AWp * (t->param.b_num + 1) * t->param.bitrate / (t->param.framerate * (rc->AWp + rc->AWb * t->param.b_num))
  205.                     - t->param.bitrate / t->param.framerate;
  206.             }
  208.             // Step 1.2 Microscopic control (target bit rate computation).
  209.             f1 = (int32_t)(t->param.bitrate / t->param.framerate + rc->gamma * (rc->tbl - rc->bc));
  210.             f1 = T264_MAX(0, f1);
  211.             f2 = (int32_t)(rc->wp * rc->gop_bits / (rc->wp * (rc->np - rc->p_no) + rc->wb * (rc->nb - rc->b_no)));
  212.             //f2 = rc->gop_bits / (rc->np - rc->p_no);
  213.             f = (int32_t)(rc->beta * f1 + (1 - rc->beta) * f2);
  215.             rc->ideal_bits = (int32_t)(f * (1 - t->param.b_num * 0.05));
  216.             // HRD consideration ??
  217.         }
  218.     }
  219.     else if (t->slice_type == SLICE_B)
  220.     {
  221.         if (rc->b_no > 0)
  222.         {
  223.             if (rc->b_no == 1)
  224.             {
  225.                 rc->AWb = rc->wb;
  226.             }
  227.             else if (rc->b_no < 8)
  228.             {
  229.                 rc->AWb = rc->wb * (rc->b_no - 1) / rc->b_no + rc->AWb/ rc->b_no;
  230.             }
  231.             else
  232.             {
  233.                 rc->AWb = rc->wb / 8 + 7 * rc->AWb / 8;
  234.             }
  235.         }
  236.     }
  237.     rc_update_qp(t, rc);
  238. }
  240. static void 
  241. rc_update_pic(T264_t* t, T264_rc_t* rc)
  242. {
  243.     int32_t X;
  245.     rc_update_quad_model(t, rc);
  246.     rc->gop_bits -= t->frame_bits;
  247.     rc->bc += (int32_t)(t->frame_bits - t->param.bitrate / t->param.framerate);
  249.     X = (int32_t)t->qp_y * t->frame_bits;
  250.     
  251.     if (t->slice_type == SLICE_P)
  252.     {
  253.         rc->qp_sum += t->qp_y;
  254.         rc->p_no ++;
  255.         rc->wp = X;
  256.         // compute mad
  257.     }
  258.     else if (t->slice_type == SLICE_B)
  259.     {
  260.         rc->b_no ++;
  261.         rc->wb = X / rc->theta;
  262.     }
  263. }
  265. double
  266. qp2qstep( int32_t qp)
  267. {
  268.     int32_t i; 
  269.     double qstep;
  270.     static const double QP2QSTEP[6] = 
  271.     {0.625, 0.6875, 0.8125, 0.875, 1.0, 1.125};
  273.     qstep = QP2QSTEP[qp % 6];
  274.     for(i = 0; i< (qp/6) ; i ++)
  275.         qstep *= 2;
  277.     return qstep;
  278. }
  280. int32_t
  281. qstep2qp(double qstep)
  282. {
  283.     int32_t q_per = 0, q_rem = 0;
  285.     if( qstep < qp2qstep(0))
  286.         return 0;
  287.     else if (qstep > qp2qstep(51))
  288.         return 51;
  290.     while( qstep > qp2qstep(5))
  291.     {
  292.         qstep /= 2;
  293.         q_per += 1;
  294.     }
  296.     if (qstep <= (0.625+0.6875)/2) 
  297.     {
  298.         qstep = 0.625;
  299.         q_rem = 0;
  300.     }
  301.     else if (qstep <= (0.6875+0.8125)/2)
  302.     {
  303.         qstep = 0.6875;
  304.         q_rem = 1;
  305.     }
  306.     else if (qstep <= (0.8125+0.875)/2)
  307.     {
  308.         qstep = 0.8125;
  309.         q_rem = 2;
  310.     }
  311.     else if (qstep <= (0.875+1.0)/2)
  312.     {
  313.         qstep = 0.875;
  314.         q_rem = 3;
  315.     }
  316.     else if (qstep <= (1.0+1.125)/2)
  317.     {
  318.         qstep = 1.0;  
  319.         q_rem = 4;
  320.     }
  321.     else 
  322.     {
  323.         qstep = 1.125;
  324.         q_rem = 5;
  325.     }
  327.     return (q_per * 6 + q_rem);
  328. }
  330. void 
  331. rc_update_qp(T264_t* t, T264_rc_t* rc)
  332. {
  333.     if (t->slice_type == SLICE_P)
  334.     {
  335.         if (rc->p_no != 0)
  336.         {
  337.             if (rc->ideal_bits < 0)
  338.             {
  339.                 t->qp_y += 2;
  340.                 t->qp_y = T264_MIN(t->qp_y, t->param.max_qp);
  341.             }
  342.             else
  343.             {
  344.                 double tmp1, tmp2;
  345.                 double step;
  346.                 int32_t bits = rc->ideal_bits - t->header_bits;
  347.                 double mad = rc->a1 * rc->mad_p + rc->a2;
  348.                 int32_t qp;
  349.                 bits = T264_MAX(bits, (int32_t)(t->param.bitrate / t->param.framerate / 4));
  350.                 tmp1 = mad * mad * rc->x1 * rc->x1 + 4 * rc->x2 * mad * bits;
  351.                 tmp2 = sqrt(tmp1) - rc->x1 * mad;
  352.                 if (rc->x2 < 0.000001 || tmp1 < 0.000001 ||  tmp2 <= 0.000001)
  353.                     step = rc->x1 * mad / bits;
  354.                 else
  355.                     step = rc->x2 * mad * 2 / tmp2;
  357.                 qp = qstep2qp(step);
  358.                 qp = T264_MIN(rc->qp_p2 + 2, qp);
  359.                 qp = T264_MIN(t->param.max_qp, qp);
  360.                 qp = T264_MAX(rc->qp_p2 - 2, qp);
  361.                 t->qp_y = T264_MAX(t->param.min_qp, qp);
  362.             }
  363.         }
  364.         rc->qp_p1 = rc->qp_p2;
  365.         rc->qp_p2 = t->qp_y;
  366.     }
  367.     else if (t->slice_type == SLICE_B)
  368.     {
  369.         if (t->param.b_num == 1)
  370.         {
  371.             if (rc->qp_p1 == rc->qp_p2)
  372.                 t->qp_y += 2;
  373.             else
  374.                 t->qp_y = (rc->qp_p1 + rc->qp_p2) / 2 + 1;
  375.             
  376.             t->qp_y = clip3(t->qp_y, t->param.min_qp, t->param.max_qp);
  377.         }
  378.         else
  379.         {
  380.             int32_t step_size;
  381.             if (rc->qp_p2 - rc->qp_p1 <= -2 * t->param.b_num - 3)
  382.                 step_size = -3;
  383.             else if (rc->qp_p2 - rc->qp_p1 == -2 * t->param.b_num - 2)
  384.                 step_size = -2;
  385.             else if (rc->qp_p2 - rc->qp_p1 == -2 * t->param.b_num - 1)
  386.                 step_size = -1;
  387.             else if (rc->qp_p2 - rc->qp_p1 == -2 * t->param.b_num - 0)
  388.                 step_size = 0;
  389.             else if (rc->qp_p2 - rc->qp_p1 == -2 * t->param.b_num + 1)
  390.                 step_size = 1;
  391.             else
  392.                 step_size = 2;
  394.             t->qp_y = rc->qp_p1 + step_size;
  395.             //t->qp_y += T264_MIN(2 * rc->b_no, 
  396.             //    T264_MAX(-2 * rc->b_no, rc->b_no * (rc->qp_p2 - rc->qp_p1) / (t->param.b_num - 1)));
  397.             t->qp_y = clip3(t->qp_y, t->param.min_qp, t->param.max_qp);
  398.         }
  399.     }
  400. }
  402. static void __inline
  403. remove_outlier(T264_t* t, int8_t valid[20], T264_rc_t* rc)
  404. {
  405.     double error[20];
  406.     int32_t i;
  407.     double std = 0.0;
  408.     double threshold;
  410.     for(i = 0 ; i < rc->window_p ; i ++)
  411.     {
  412.         error[i] = rc->x1 / rc->qp[i] + rc->x2 / (rc->qp[i] * rc->rp[i]) - rc->qp[i];
  413.         std += error[i] * error[i];
  414.     }
  416.     threshold = rc->window_p == 2 ? 0 : sqrt(std / rc->window_p);
  418.     for(i = 1 ; i < rc->window_p ; i ++)
  419.     {
  420.         if (error[i] > threshold)
  421.             valid[i] = FALSE;
  422.     }
  423. }
  425. static void __inline
  426. remove_mad_outlier(T264_t* t, int8_t valid[20], T264_rc_t* rc)
  427. {
  428.     double error[20];
  429.     int32_t i;
  430.     double std = 0.0;
  431.     double threshold;
  433.     for(i = 0 ; i < rc->mad_window_p ; i ++)
  434.     {
  435.         error[i] = rc->a1 * rc->mad[i + 1] + rc->a2 - rc->mad[i];
  436.         std += error[i] * error[i];
  437.     }
  439.     threshold = rc->mad_window_p == 2 ? 0 : sqrt(std / rc->mad_window_p);
  441.     for(i = 1 ; i < rc->mad_window_p ; i ++)
  442.     {
  443.         if (error[i] > threshold)
  444.             valid[i] = FALSE;
  445.     }
  446. }
  448. void
  449. mad_model_estimator(T264_t* t, int8_t valid[20], int32_t window, T264_rc_t* rc)
  450. {
  451.     int32_t real_window = 0, i;
  452.     int8_t estimate_x2 = FALSE;
  453.     double a00 = 0.0, a01 = 0.0, a10 = 0.0, a11 = 0.0, b0 = 0.0, b1 = 0.0;
  454.     double mad;
  455.     double matrix_value;
  457.     for(i = 0 ; i < window ; i ++)
  458.     {
  459.         if (valid[i])
  460.         {
  461.             real_window ++;
  462.             mad = rc->mad[i];
  463.         }
  464.     }
  466.     rc->a1 = rc->a2 = 0.0;
  467.     for(i = 0 ; i < window ; i ++)
  468.     {
  469.         if (valid[i])
  470.         {
  471.             rc->a1 += rc->mad[i] / (rc->mad[i + 1] * real_window);
  472.             if (ABS(mad - rc->mad[i]) < 0.00001)
  473.                 estimate_x2 = TRUE;
  474.         }
  475.     }
  477.     if (real_window >= 1 && estimate_x2)
  478.     {
  479.         for(i = 0 ; i < window ; i ++)
  480.         {
  481.             if (valid[i])
  482.             {
  483.                 a00 += 1.0;
  484.                 a01 += rc->mad[i + 1];
  485.                 a10 = a01;
  486.                 a11 += rc->mad[i + 1] * rc->mad[i + 1];
  487.                 b0 += rc->mad[i];
  488.                 b1 += rc->mad[i] * rc->mad[i + 1];
  489.             }
  490.         }
  492.         matrix_value = a00 * a11 - a01 * a10;
  493.         if (ABS(matrix_value) > 0.000001)
  494.         {
  495.             rc->a2 = (b0 * a11 - b1 * a01) / matrix_value;
  496.             rc->a1 = (b1 * a00 - b0 * a10) / matrix_value;
  497.         }
  498.         else
  499.         {
  500.             rc->a1 = b0 / a01;
  501.             rc->a2 = 0.0;
  502.         }
  503.     }
  504. }
  506. void
  507. rc_update_mad_model(T264_t* t, T264_rc_t* rc)
  508. {
  509.     int32_t i;
  510.     int32_t window;
  511.     double mad;
  512.     int8_t valid[20];
  514.     if (t->slice_type == SLICE_P)
  515.     {
  516.         mad = ((double)t->sad_all) / ((double)(t->width * t->height));
  517.         // update x1, x2
  518.         for (i = 19 ; i > 0 ; i --)
  519.         {
  520.             rc->mad[i] = rc->mad[i - 1];
  521.         }
  522.         rc->mad[0] = mad;
  523.         window = (int32_t)(mad > rc->mad_p ? rc->mad_p / mad * 20 : mad / rc->mad_p * 20);
  524.         window = clip3(1, rc->p_no + 1, window);
  525.         window = T264_MIN(window, rc->mad_window_p + 1);
  526.         window = T264_MIN(window, 20);
  527.         rc->mad_window_p = window;
  528.         memset(valid, TRUE, sizeof(valid));
  529.         mad_model_estimator(t, valid, window, rc);
  530.         remove_mad_outlier(t, valid, rc);
  531.         mad_model_estimator(t, valid, window, rc);
  532.     }
  533. }
  535. void
  536. quad_model_estimator(T264_t* t, int8_t valid[20], int32_t window, T264_rc_t* rc)
  537. {
  538.     int32_t real_window = 0, i;
  539.     int8_t estimate_x2 = FALSE;
  540.     double a00 = 0.0, a01 = 0.0, a10 = 0.0, a11 = 0.0, b0 = 0.0, b1 = 0.0;
  541.     double qp;
  542.     double matrix_value;
  544.     for(i = 0 ; i < window ; i ++)
  545.     {
  546.         if (valid[i])
  547.         {
  548.             real_window ++;
  549.             qp = rc->qp[i];
  550.         }
  551.     }
  553.     rc->x1 = rc->x2 = 0.0;
  554.     for(i = 0 ; i < window ; i ++)
  555.     {
  556.         if (valid[i])
  557.         {
  558.             rc->x1 += rc->qp[i] * rc->rp[i] / real_window;
  559.             if (qp != rc->qp[i])
  560.                 estimate_x2 = TRUE;
  561.         }
  562.     }
  564.     if (real_window >= 1 && estimate_x2)
  565.     {
  566.         for(i = 0 ; i < window ; i ++)
  567.         {
  568.             if (valid[i])
  569.             {
  570.                 a00 += 1.0;
  571.                 a01 += 1.0 / rc->qp[i];
  572.                 a10 = a01;
  573.                 a11 += 1.0 / (rc->qp[i] * rc->rp[i]);
  574.                 b0 += rc->qp[i] * rc->rp[i];
  575.                 b1 += rc->rp[i];
  576.             }
  577.         }
  579.         matrix_value = a00 * a11 - a01 * a10;
  580.         if (ABS(matrix_value) > 0.000001)
  581.         {
  582.             rc->x1 = (b0 * a11 - b1 * a01) / matrix_value;
  583.             rc->x2 = (b1 * a00 - b0 * a10) / matrix_value;
  584.         }
  585.         else
  586.         {
  587.             rc->x1 = b0 / a00;
  588.             rc->x2 = 0.0;
  589.         }
  590.     }
  591. }
  593. static void 
  594. rc_update_quad_model(T264_t* t, T264_rc_t* rc)
  595. {
  596.     int32_t i;
  597.     int32_t window;
  598.     double mad;
  599.     int8_t valid[20];
  601.     if (t->slice_type == SLICE_P)
  602.     {
  603.         mad = ((double)t->sad_all) / ((double)(t->width * t->height));
  604.         // update x1, x2
  605.         for (i = 19 ; i > 0 ; i --)
  606.         {
  607.             rc->qp[i] = rc->qp[i - 1];
  608.             rc->rp[i] = rc->rp[i - 1];
  609.         }
  610.         rc->qp[0] = t->qp_y;
  611.         rc->rp[0] = ((double)(t->frame_bits - t->header_bits)) / mad;
  612.         window = (int32_t)(mad > rc->mad_p ? rc->mad_p / mad * 20 : mad / rc->mad_p * 20);
  613.         window = clip3(1, rc->p_no + 1, window);
  614.         window = T264_MIN(window, rc->window_p + 1);
  615.         window = T264_MIN(window, 20);
  616.         rc->window_p = window;
  617.         if (window > 0)
  618.         {
  619.             memset(valid, TRUE, sizeof(valid));
  620.             quad_model_estimator(t, valid, window, rc);
  621.             remove_outlier(t, valid, rc);
  622.             quad_model_estimator(t, valid, window, rc);
  623.         }
  624.         if (rc->p_no > 0)
  625.         {
  626.             // update a1, a2
  627.             rc_update_mad_model(t, rc);
  628.         }
  629.         else
  630.         {
  631.             rc->mad[0] = mad;
  632.         }
  633.         rc->mad_p = mad;
  634.     }
  635. }
  637. static void
  638. rc_proc(T264_t* t, void* data, int32_t state)
  639. {
  640.     T264_rc_t* rc = data;
  641.     switch (state) 
  642.     {
  643.     case STATE_BEFOREPIC:
  644.         rc_init_pic(t, rc);
  645.         break;
  646.     case STATE_AFTERPIC:
  647.         rc_update_pic(t, rc);
  648.         break;
  649.     case STATE_BEFOREGOP:
  650.         rc_init_gop(t, rc);
  651.         break;
  652.     case STATE_BEFORESEQ:
  653.         rc_init_seq(t, rc);
  654.         break;
  655.     default:
  656.         break;
  657.     }
  658. }
  660. void
  661. rc_create(T264_t* t, T264_plugin_t* plugin)
  662. {
  663.     T264_rc_t* handle = malloc(sizeof(T264_rc_t));
  664.     memset(handle, 0, sizeof(T264_rc_t));
  666.     plugin->handle = handle;
  667.     plugin->proc = rc_proc;
  668.     plugin->close = rc_destroy;
  669.     plugin->ret = 0;
  670. }
  672. void
  673. rc_destroy(T264_t* t, T264_plugin_t* plugin)
  674. {
  675.     free(plugin->handle);
  676. }