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

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

mpeg/mp3

开发平台：

Visual C++

T264.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. // T264.cpp : Defines the entry point for the console application.
  25. //
  27. //#define USE_DISPLAY
  28. #include "config.h"
  30. #ifdef USE_DISPLAY
  31. #ifndef __GCC__
  32. #include "win.h"
  33. #else
  34. #include "display.h"
  35. #endif
  36. #endif
  38. //Ti_DSP Platform ported by YouXiaoquan,HFUT-Ti United Lab,China
  39. //YouXiaoquan@126.com
  40. #include "stdio.h"
  41. #ifndef CHIP_DM642
  42. #include "sys/timeb.h"
  43. #endif
  44. #include "time.h"
  46. #include "stdlib.h"
  47. #ifndef CHIP_DM642
  48. #include "memory.h"
  49. #endif
  50. #include "math.h"
  51. #include "T264.h"
  52. #include "utility.h"
  53. #include "string.h"
  56. // parameters begin
  57. int32_t total_no = 300;
  58. char src_path[256];
  59. char out_path[256];
  60. char rec_path[256];
  61. // for decoder PSNR
  62. char ref_path[256];
  63. static int  ref_skip;
  65. // parameters end
  67. #ifdef USE_DISPLAY
  69. void
  70. winDisplay(T264_t* t, T264_frame_t* f)
  71. {
  72.     uint8_t* p;
  73.     unsigned char* buffer1, *buffer2, *buffer3, *Y, *U, *V;
  74.     unsigned char *src[3];
  75.     int32_t i;
  77.     src[0] = Y = buffer1 = malloc(t->width*t->height*sizeof(char));
  78.     p = f->Y[0];
  79.     for (i = 0 ; i < t->height ; i++)
  80.     {
  81.         memcpy(buffer1, p, t->width);
  82.         buffer1 += t->width;
  83.         p += t->edged_stride;
  84.     }
  86.     src[2] = V = buffer2 = malloc((t->width*t->height*sizeof(char))>>2);
  87.     p = f->V;
  88.     for (i = 0 ; i < (t->height >> 1); i++)
  89.     {
  90.         memcpy(buffer2, p, t->width >> 1);
  91.         buffer2 += (t->width >> 1);
  92.         p += t->edged_stride_uv;
  93.     }
  95.     src[1] = U = buffer3 = malloc((t->width*t->height*sizeof(char))>>2);
  96.     p = f->U;
  97.     for (i = 0 ; i < (t->height >> 1); i++)
  98.     {
  99.         memcpy(buffer3, p, t->width >> 1);
  100.         buffer3 += (t->width >> 1);
  101.         p += t->edged_stride_uv;
  102.     }
  103. #ifndef __GCC__
  104.     displayImage(Y,V,U);
  105. #else
  106.     dither(src);
  107.     free(src[1]);
  108.     free(src[2]);
  109.     free(src[0]);
  110. #endif
  111. }
  113. void
  114. uninit_display()
  115. {
  116. #ifndef __GCC__
  117.     closeDisplay ();
  118. #else
  119.     exit_display();
  120. #endif
  121. }
  122. #endif
  124. void
  125. init_param(T264_param_t* param, const char* file)
  126. {
  127.     FILE* fd; 
  128.     char line[255];
  129.     int32_t b;
  130.     if (!(fd = fopen(file,"r")))
  131.     {
  132.         printf("Couldn't open parameter file %s.n", file);
  133.         exit(-1);
  134.     }
  136.     memset(param, 0, sizeof(*param));
  137.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  138.     if (b != 4)
  139.     {
  140.         printf("wrong param file version, expect v4.0n");
  141.         exit(-1);
  142.     }
  143.     fgets(line, 254, fd); sscanf(line,"%d", &param->width);
  144.     fgets(line, 254, fd); sscanf(line,"%d", &param->height);
  145.     fgets(line, 254, fd); sscanf(line,"%d", &param->search_x);
  146.     fgets(line, 254, fd); sscanf(line,"%d", &param->search_y);
  147.     fgets(line, 254, fd); sscanf(line,"%d", &total_no);
  148.     fgets(line, 254, fd); sscanf(line,"%d", &param->iframe);
  149.     fgets(line, 254, fd); sscanf(line,"%d", &param->idrframe);
  150.     fgets(line, 254, fd); sscanf(line,"%d", &param->b_num);
  151.     fgets(line, 254, fd); sscanf(line,"%d", &param->ref_num);
  152.     fgets(line, 254, fd); sscanf(line,"%d", &param->enable_rc);
  153.     fgets(line, 254, fd); sscanf(line,"%d", &param->bitrate);
  154.     fgets(line, 254, fd); sscanf(line,"%f", &param->framerate);
  155.     fgets(line, 254, fd); sscanf(line,"%d", &param->qp);
  156.     fgets(line, 254, fd); sscanf(line,"%d", &param->min_qp);
  157.     fgets(line, 254, fd); sscanf(line,"%d", &param->max_qp);
  158.     fgets(line, 254, fd); sscanf(line,"%d", &param->enable_stat);
  159.     fgets(line, 254, fd); sscanf(line,"%d", &param->disable_filter);
  160.     fgets(line, 254, fd); sscanf(line,"%d", &param->aspect_ratio);
  161.     fgets(line, 254, fd); sscanf(line,"%d", &param->video_format);
  162.     fgets(line, 254, fd); sscanf(line,"%d", &param->luma_coeff_cost);
  163.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  164.     param->flags |= (USE_INTRA16x16) * (!!b);
  165.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  166.     param->flags |= (USE_INTRA4x4) * (!!b);
  167.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  168.     param->flags |= (USE_INTRAININTER) * (!!b);
  169.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  170.     param->flags |= (USE_HALFPEL) * (!!b);
  171.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  172.     param->flags |= (USE_QUARTPEL) * (!!b);
  173.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  174.     param->flags |= (USE_SUBBLOCK) * (!!b);
  175.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  176.     param->flags |= (USE_FULLSEARCH) * (!!b);
  177.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  178.     param->flags |= (USE_DIAMONDSEACH) * (!!b);
  179.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  180.     param->flags |= (USE_FORCEBLOCKSIZE) * (!!b);
  181.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  182.     param->flags |= (USE_FASTINTERPOLATE) * (!!b);
  183.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  184.     param->flags |= (USE_SAD) * (!!b);
  185.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  186.     param->flags |= (USE_EXTRASUBPELSEARCH) * (!!b);
  187.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  188.     param->flags |= (USE_SCENEDETECT) * (!!b);
  189.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  190.     param->block_size |= (SEARCH_16x16P) * (!!b);
  191.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  192.     param->block_size |= (SEARCH_16x8P) * (!!b);
  193.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  194.     param->block_size |= (SEARCH_8x16P) * (!!b);
  195.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  196.     param->block_size |= (SEARCH_8x8P) * (!!b);
  197.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  198.     param->block_size |= (SEARCH_8x4P) * (!!b);
  199.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  200.     param->block_size |= (SEARCH_4x8P) * (!!b);
  201.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  202.     param->block_size |= (SEARCH_4x4P) * (!!b);
  203.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  204.     param->block_size |= (SEARCH_16x16B) * (!!b);
  205.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  206.     param->block_size |= (SEARCH_16x8B) * (!!b);
  207.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  208.     param->block_size |= (SEARCH_8x16B) * (!!b);
  209.     fgets(line, 254, fd); sscanf(line,"%d", &b);
  210.     param->block_size |= (SEARCH_8x8B) * (!!b);
  211.     fgets(line, 254, fd); sscanf(line,"%d", &param->cpu);
  212.     fgets(line, 254, fd); sscanf(line, "%d", &param->cabac);
  214.     fgets(line, 254, fd); sscanf(line,"%s", src_path);
  215.     fgets(line, 254, fd); sscanf(line,"%s", out_path);
  216.     fgets(line, 254, fd); sscanf(line,"%s", rec_path);
  217.     param->rec_name = rec_path;
  219.     fclose(fd);
  220. }
  222. int32_t 
  223. encode(const char* paramfile)
  224. {
  225.     T264_param_t param;
  226.     T264_t* t;
  227.     uint8_t* buf, *dst;
  228.     int32_t size;
  229.     FILE* in_file, *out_file;
  230.     uint32_t len;
  231.     int32_t frame_no;
  232.     int32_t bs_len = 0;
  234.     uint8_t* rec;
  236.     float total_time;
  237. #ifdef _WIN32
  238.     struct _timeb beg, end;
  239. #endif
  241. #ifdef CHIP_DM642 
  242. clock_t start_T=0,end_T=0,total_T=0;
  243. #endif
  244.     init_param(&param, paramfile);
  246.     param.direct_flag = 1;
  247.     // NOTE: currently we force p reference frame num = 1
  248.     t = T264_open(&param);
  250.     /* YV12p */
  251.     size = param.height * param.width + (param.height * param.width >> 1);
  252.     buf = T264_malloc(size, CACHE_SIZE);
  253.     in_file = fopen(src_path, "rb");
  254.     if (!in_file)
  255.     {
  256.         printf("cannot open input file.");
  257.         return 0;
  258.     }
  260.     out_file = fopen(out_path, "wb");
  261.     if (!out_file)
  262.     {
  263.         printf("cannot write 264 file.n");
  264.         return 0;
  265.     }
  267.     dst = T264_malloc(size, CACHE_SIZE);
  268.     rec = T264_malloc(size, CACHE_SIZE);
  270. #ifdef _WIN32
  271.     _ftime(&beg);
  272. #endif
  273.     printf("frame poc length qp Y U Vn");
  274.     for(frame_no = 0; frame_no < total_no; frame_no++)
  275.     {        
  276.         if (fread(buf, size, 1, in_file) <= 0)
  277.             printf("cannot read from input file.");
  278. #ifdef CHIP_DM642
  279. start_T=clock();
  280. #endif
  281.         len = T264_encode(t, buf, dst, size);
  282. #ifdef CHIP_DM642 
  283. end_T=clock();
  284. total_T=total_T+end_T-start_T-192;
  285. #endif    
  286.         bs_len += len;
  288.         if (fwrite(dst, len, 1, out_file) < 0)
  289.             printf("cannot write 264 file.n");
  290.     }
  291. #ifndef CHIP_DM642
  292. #ifdef _WIN32
  293.     _ftime(&end);
  294.     total_time = (float)(end.time - beg.time) + (float)(end.millitm - beg.millitm) / 1000;
  295. #endif
  296.     printf("fps: %.2ffps, Length of Bitstream = %d Compact Ratio = %.2fn", (float)(total_no) / total_time, bs_len, 1.0 * total_no * size / bs_len);
  297. #endif
  298. #ifdef CHIP_DM642
  299. printf("fps: %.2ffps with cpu 600MHz, Length of Bitstream = %d Compact Ratio = %.2fn", ((float)total_no /((float)total_T/(float)600000000)),  bs_len, 1.0 * total_no * size / bs_len);
  300. #endif
  301.     fclose(in_file);
  302.     fclose(out_file);
  303.     T264_free(dst);
  304.     T264_close(t);
  306.     return 0;
  307. }
  309. void
  310. write_frame(T264_t* t,T264_frame_t *frame,FILE *f_rec)
  311. {
  312.     int i;
  313.     uint8_t* p;
  315.     if (f_rec)
  316.     {
  317.         p = frame->Y[0];
  318.         for(i = 0 ; i < t->height ; i ++)
  319.         {
  320.             fwrite(p, t->width, 1, f_rec);
  321.             p += t->edged_stride;
  322.         }
  323.         p = frame->U;
  324.         for(i = 0 ; i < t->height >> 1 ; i ++)
  325.         {
  326.             fwrite(p, t->width >> 1, 1, f_rec);
  327.             p += t->edged_stride_uv;
  328.         }
  329.         p = frame->V;
  330.         for(i = 0 ; i < t->height >> 1 ; i ++)
  331.         {
  332.             fwrite(p, t->width >> 1, 1, f_rec);
  333.             p += t->edged_stride_uv;
  334.         }
  335.     }
  336. }
  337. static float __inline
  338. dec_psnr(uint8_t* p1, uint8_t* p2, int32_t width1, int32_t width2, int32_t height, int print)
  339. {
  340. float sad = 0, psnr;
  341. int32_t i, j, size, ii, jj, diff, iii, jjj;
  342. uint8_t* p11, *p22;
  343. for(j=0; j<height; j+=16)
  344. {
  345. for (i = 0 ; i < width2 ; i +=16)
  346. {
  347. p11 = p1+i;
  348. p22 = p2+i;
  349. diff = 0;
  350. for(jj=0; jj<16; jj++)
  351. {
  352. for(ii=0; ii<16; ii++)
  353. {
  354. int32_t tmp;
  355. tmp = (p11[ii] - p22[ii]);
  356. sad += tmp * tmp;
  357. if(tmp != 0 && diff != 1)
  358. {
  359. if(print)
  360. printf("%2d != %2d ", p11[ii], p22[ii]);
  361. iii = ii;
  362. jjj = jj;
  363. diff = 1;
  364. }
  365. }
  366. p11 += width1;
  367. p22 += width2;
  368. }
  369. if(diff && print)
  370. {
  371. printf("%4d, %2d, %2dn", (j)*(width2>>4) + (i), iii, jjj);
  372. print = 0;
  373. }
  374. }
  375. p1 += width1*16;
  376. p2 += width2*16;
  377. }
  378. size = width2 * height;
  379. if(sad < 1e-6)
  380. psnr = 0.0f;
  381. else
  382. psnr = (float)(10 * log10(65025.0f * size / sad));
  383. return psnr;
  384. }
  386. int32_t 
  387. decode(const char* filename)
  388. {
  389.     /* just for show how to drive the decoder */
  390. #define BUFFER_SIZE 4096
  391.     T264_t* t = T264dec_open();
  392.     uint8_t buffer[BUFFER_SIZE + 4];
  393.     int32_t run = 1,screen = 0;
  394.     FILE* src_file = fopen(filename, "rb");
  395.     size_t size;
  396.     FILE* f_rec = 0;
  397. //for decoder PSNR
  398. int frame_num = 0;
  399. FILE* f_ref = 0;
  400. uint8_t *ref_buf = NULL;
  401.     int32_t frame_nums = 0;
  403.     float total_time;
  404. #ifdef _WIN32
  405.     struct _timeb beg, end;
  406. #endif
  408.     // xxx
  409.     printf("Current fully support t264 encoder's bitstream.n");
  411.     if (!src_file)
  412.     {
  413.         printf("cannot open file %s.n", filename);
  414.         return -1;
  415.     }
  416.     if (rec_path[0])
  417.     {
  418.         f_rec = fopen(rec_path, "wb");
  419.         if (!f_rec)
  420.         {
  421.             printf("cannot open rec file %s.n", rec_path);
  422.         }
  423.     }
  424. //for decoder PSNR
  425. if(ref_path[0])
  426. {
  427. f_ref = fopen(ref_path, "rb");
  428. if(!f_ref)
  429. {
  430. printf("cannot open ref file %s.n", ref_path);
  431. }
  432. }
  434. #ifdef _WIN32
  435.     _ftime(&beg);
  436. #endif
  437.     while (run) 
  438.     {
  439.         decoder_state_t state = T264dec_parse(t);
  440.         switch(state) 
  441.         {
  442.         case DEC_STATE_BUFFER:
  443.             /* read more data */
  444.             size = fread(buffer, 1, BUFFER_SIZE, src_file);
  445.             if (size > 0)
  446.             {
  447.                 if (size != BUFFER_SIZE)
  448.                 {
  449.                     buffer[size] = 0;
  450.                     buffer[size + 1] = 0;
  451.                     buffer[size + 2] = 0;
  452.                     buffer[size + 3] = 1;
  453.                     size += 4;
  454.                 }
  456.                 T264dec_buffer(t, buffer, size);
  457.             }
  458.             else
  459.             {
  460.                 /* if all data has readed, here we will return */
  461.                 run = 0;
  462.                 /* NOTE: here we should get the last frame */
  463.                 write_frame(t, T264dec_flush_frame(t), f_rec);
  464. #ifdef USE_DISPLAY
  465.                 winDisplay(t, T264dec_flush_frame(t));
  466. #endif
  467.                 frame_nums ++;
  468.             }
  469.             break;
  470.         case DEC_STATE_PIC:
  471.             /* write one pic */
  472.             break;
  473.         case DEC_STATE_SEQ:
  475. #ifdef USE_DISPLAY
  476.             if (screen == 0)
  477.             {
  478. #ifndef __GCC__
  479.                 initDisplay(t->width, t->height);
  480. #else
  481.                 init_display("",t->width, t->height);
  482. #endif
  483.                 screen++;
  484.             }
  486. #endif
  487.             if (t->frame_id > 0)
  488.             {
  489.                 /* NOTE: here we should get the last frame */
  490.                 write_frame(t, T264dec_flush_frame(t), f_rec);
  491.     #ifdef USE_DISPLAY
  492.                 winDisplay(t, T264dec_flush_frame(t));
  493.     #endif
  494.                 frame_nums ++;
  495.             }
  496.             printf("ref frames num: %d.n", t->ss.num_ref_frames);
  497.             printf("width: %d.n", (t->ss.pic_width_in_mbs_minus1 + 1) << 4);
  498.             printf("height: %d.n", (t->ss.pic_height_in_mbs_minus1 + 1) << 4);
  499.             break;
  500.         case DEC_STATE_SLICE:
  501.             {
  502.                 if (t->output.poc >= 0)
  503.                 {
  504.                     write_frame(t, &t->output, f_rec);
  505. //for decoder PSNR
  506. if(f_ref)
  507. {
  508. float psnr_y, psnr_u, psnr_v;
  509. int size;
  510. size = t->width*t->height;
  511. if(ref_buf == NULL)
  512. {
  513. ref_buf = (uint8_t *)malloc(size);
  514. }
  516. if(ref_buf != NULL)
  517. {
  518. uint8_t *p;
  519. p = t->output.Y[0];
  520. fread(ref_buf, 1, size, f_ref);
  521. psnr_y = dec_psnr(p, ref_buf, t->edged_stride, t->width, t->height, 0);
  523. size >>= 2;
  524. p = t->output.U;
  525. fread(ref_buf, 1, size, f_ref);
  526. psnr_u = dec_psnr(p, ref_buf, t->edged_stride_uv, t->width>>1, t->height>>1, 0);
  527. p = t->output.V;
  528. fread(ref_buf, 1, size, f_ref);
  529. psnr_v = dec_psnr(p, ref_buf, t->edged_stride_uv, t->width>>1, t->height>>1, 0);
  530. printf("%4d, %.2f, %.2f, %.2fn", frame_num++, psnr_y, psnr_u, psnr_v);
  531. if(ref_skip > 0)
  532. {
  533. fseek(f_ref, ref_skip*size*6, SEEK_CUR);
  534. }
  535. }
  536. }
  537. #ifdef USE_DISPLAY
  538.                     winDisplay(t, &t->output);
  539. #endif
  540.                     frame_nums ++;                
  541.                 }
  542.             };
  543.             break;
  544.         case DEC_STATE_CUSTOM_SET:
  545.             {
  546.                 printf("used fast interpolate: %s.n", t->flags & USE_FASTINTERPOLATE ? "yes" : "no");
  547.             }
  548.             break;
  549.         default:
  550.             /* do not care */
  551.             break;
  552.         }
  553.     };
  555. #ifndef CHIP_DM642
  556. #ifdef _WIN32
  557.     _ftime(&end);
  558.     total_time = (float)(end.time - beg.time) + (float)(end.millitm - beg.millitm) / 1000;
  559. #endif
  560.     printf("fps: %.2ffps(total decode: %d frames).n", (float)frame_nums / total_time, frame_nums);
  561. #endif    
  562. #ifdef CHIP_DM642
  563. printf("fps: %.2ffps(total decode: %d frames).n", (float)frame_nums / total_time, frame_nums);
  564. #endif
  565.     T264dec_close(t);
  566.     fclose(src_file);
  567.     if (f_rec)
  568.         fclose(f_rec);
  569. if (f_ref)
  570. fclose(f_ref);
  571. if(ref_buf != NULL)
  572. free(ref_buf);
  573. #ifdef USE_DISPLAY
  574.     uninit_display();
  575. #endif
  577.     return 0;
  578. }
  580. void
  581. help()
  582. {
  583.     printf("Usage:n"
  584.         "tt264 -d test.264 [rec_path] [reference_path] [skip_num](to decode a 264 file.)n"
  585.         "tt264 -e enconfig.txt (to encode a 264 file.)n");
  586. }
  588. int 
  589. main(int argc, char* argv[])
  590. {
  591.     int32_t i;
  592.     int32_t is_encode = 0;
  593.     int32_t is_decode = 0;
  594.     char* file_name;
  596.     printf("T264 ver: %d.%02dn", T264_MAJOR, T264_MINOR);
  597.     if (argc < 3)
  598.     {
  599.         help();
  600.         return 0;
  601.     }
  603.     for (i = 1 ; i < 3 ; i ++)
  604.     {
  605.         if (strcmp(argv[i], "-d") == 0)
  606.         {
  607.             is_decode = 1;
  608.         }
  609.         else if(strcmp(argv[i], "-e") == 0)
  610.         {
  611.             is_encode = 1;
  612.         }
  613.         else
  614.         {
  615.             file_name = argv[i];
  616.         }
  617.     }
  619.     if (is_encode)
  620.     {
  621.         return encode(file_name);
  622.     }
  624.     if (is_decode)
  625.     {
  626.         if (argc <= 3)
  627.             rec_path[0] = 0;
  628.         else
  629. {
  630. strcpy(rec_path, argv[3]);
  631. }
  632. if(argc <= 4)
  633. {
  634. ref_path[0] = 0;
  635. }
  636. else
  637. {
  638. strcpy(ref_path, argv[4]);
  639. }
  640. if(argc > 5)
  641. {
  642. ref_skip = atoi(argv[5]);
  643. }
  644.         return decode(file_name);
  645.     }
  647.     help();
  649.     return -1;
  650. }