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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
h263enc.c
资源名称：ffmpeg-0.3.4.tar.gz　[点击查看]
上传用户：jxp0626
上传日期：2007-01-08
资源大小：102k
文件大小：16k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Unix_Linux

h263enc.c：源码内容
  1. /*
  2.  * H263 backend for ffmpeg encoder
  3.  * Copyright (c) 2000 Gerard Lantau.
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19. #include <stdlib.h>
  20. #include <stdio.h>
  21. #include <netinet/in.h>
  22. #include "common.h"
  23. #include "dsputil.h"
  24. #include "mpegvideo.h"
  25. #include "h263data.h"
  26. #include "mpeg4data.h"
  28. #define NDEBUG
  29. #include <assert.h>
  31. static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
  32.       int n);
  33. static void h263_encode_motion(MpegEncContext * s, int val);
  34. static void h263_pred_motion(MpegEncContext * s, int block, int *px, int *py);
  35. static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
  36.        int n);
  38. void h263_picture_header(MpegEncContext * s, int picture_number)
  39. {
  40.     int format;
  42.     align_put_bits(&s->pb);
  43.     put_bits(&s->pb, 22, 0x20);
  44.     put_bits(&s->pb, 8, ((s->picture_number * 30) / s->frame_rate) & 0xff);
  46.     put_bits(&s->pb, 1, 1); /* marker */
  47.     put_bits(&s->pb, 1, 0); /* h263 id */
  48.     put_bits(&s->pb, 1, 0); /* split screen off */
  49.     put_bits(&s->pb, 1, 0); /* camera  off */
  50.     put_bits(&s->pb, 1, 0); /* freeze picture release off */
  52.     if (s->width == 128 && s->height == 96)
  53. format = 1;
  54.     else if (s->width == 176 && s->height == 144)
  55. format = 2;
  56.     else if (s->width == 352 && s->height == 288)
  57. format = 3;
  58.     else if (s->width == 704 && s->height == 576)
  59. format = 4;
  60.     else if (s->width == 1408 && s->height == 1152)
  61. format = 5;
  62.     else
  63. abort();
  65.     put_bits(&s->pb, 3, format);
  67.     put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
  69.     put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
  71.     put_bits(&s->pb, 1, 0); /* SAC: off */
  73.     put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
  75.     put_bits(&s->pb, 1, 0); /* not PB frame */
  77.     put_bits(&s->pb, 5, s->qscale);
  79.     put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
  81.     put_bits(&s->pb, 1, 0); /* no PEI */
  82. }
  84. void h263_encode_mb(MpegEncContext * s,
  85.     DCTELEM block[6][64],
  86.     int motion_x, int motion_y)
  87. {
  88.     int cbpc, cbpy, i, cbp, pred_x, pred_y;
  90.     if (!s->mb_intra) {
  91. /* compute cbp */
  92. cbp = 0;
  93. for (i = 0; i < 6; i++) {
  94.     if (s->block_last_index[i] >= 0)
  95. cbp |= 1 << (5 - i);
  96. }
  97. if ((cbp | motion_x | motion_y) == 0) {
  98.     /* skip macroblock */
  99.     put_bits(&s->pb, 1, 1);
  100.     return;
  101. }
  102. put_bits(&s->pb, 1, 0); /* mb coded */
  103. cbpc = cbp & 3;
  104. put_bits(&s->pb,
  105.  inter_MCBPC_bits[cbpc],
  106.  inter_MCBPC_code[cbpc]);
  107. cbpy = cbp >> 2;
  108. cbpy ^= 0xf;
  109. put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
  111. /* motion vectors: 16x16 mode only now */
  112.         h263_pred_motion(s, 0, &pred_x, &pred_y);
  113.         
  114.         h263_encode_motion(s, motion_x - pred_x);
  115.         h263_encode_motion(s, motion_y - pred_y);
  116.     } else {
  117. /* compute cbp */
  118. cbp = 0;
  119. for (i = 0; i < 6; i++) {
  120.     if (s->block_last_index[i] >= 1)
  121. cbp |= 1 << (5 - i);
  122. }
  124. cbpc = cbp & 3;
  125. if (s->pict_type == I_TYPE) {
  126.     put_bits(&s->pb,
  127.      intra_MCBPC_bits[cbpc],
  128.      intra_MCBPC_code[cbpc]);
  129. } else {
  130.     put_bits(&s->pb, 1, 0); /* mb coded */
  131.     put_bits(&s->pb,
  132.      inter_MCBPC_bits[cbpc + 4],
  133.      inter_MCBPC_code[cbpc + 4]);
  134. }
  135. if (s->h263_pred) {
  136.     /* XXX: currently, we do not try to use ac prediction */
  137.     put_bits(&s->pb, 1, 0); /* no ac prediction */
  138. }
  139. cbpy = cbp >> 2;
  140. put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
  141.     }
  143.     /* encode each block */
  144.     if (s->h263_pred) {
  145. for (i = 0; i < 6; i++) {
  146.     mpeg4_encode_block(s, block[i], i);
  147. }
  148.     } else {
  149. for (i = 0; i < 6; i++) {
  150.     h263_encode_block(s, block[i], i);
  151. }
  152.     }
  153. }
  155. static inline int mid_pred(int a, int b, int c)
  156. {
  157.     int vmin, vmax;
  158.     vmin = a;
  159.     if (b < vmin)
  160.         vmin = b;
  161.     if (c < vmin)
  162.         vmin = c;
  164.     vmax = a;
  165.     if (b > vmax)
  166.         vmax = b;
  167.     if (c > vmax)
  168.         vmax = c;
  170.     return a + b + c - vmin - vmax;
  171. }
  173. static void h263_pred_motion(MpegEncContext * s, int block, int *px, int *py)
  174. {
  175.     int x, y, wrap;
  176.     INT16 *A, *B, *C;
  178.     x = 2 * s->mb_x + 1 + (block & 1);
  179.     y = 2 * s->mb_y + 1 + ((block >> 1) & 1);
  180.     wrap = 2 * s->mb_width + 2;
  182.     /* special case for first line */
  183.     if (y == 1) {
  184.         A = s->motion_val[(x-1) + (y) * wrap];
  185.         *px = A[0];
  186.         *py = A[1];
  187.         return;
  188.     }
  190.     switch(block) {
  191.     default:
  192.     case 0:
  193.         A = s->motion_val[(x-1) + (y) * wrap];
  194.         B = s->motion_val[(x) + (y-1) * wrap];
  195.         C = s->motion_val[(x+2) + (y-1) * wrap];
  196.         break;
  197.     case 1:
  198.     case 2:
  199.         A = s->motion_val[(x-1) + (y) * wrap];
  200.         B = s->motion_val[(x) + (y-1) * wrap];
  201.         C = s->motion_val[(x+1) + (y-1) * wrap];
  202.         break;
  203.     case 3:
  204.         A = s->motion_val[(x-1) + (y) * wrap];
  205.         B = s->motion_val[(x-1) + (y-1) * wrap];
  206.         C = s->motion_val[(x) + (y-1) * wrap];
  207.         break;
  208.     }
  209.     *px = mid_pred(A[0], B[0], C[0]);
  210.     *py = mid_pred(A[1], B[1], C[1]);
  211. }
  214. static void h263_encode_motion(MpegEncContext * s, int val)
  215. {
  216.     int range, l, m, bit_size, sign, code, bits;
  218.     if (val == 0) {
  219.         /* zero vector */
  220.         code = 0;
  221.         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
  222.     } else {
  223.         bit_size = s->f_code - 1;
  224.         range = 1 << bit_size;
  225.         /* modulo encoding */
  226.         l = range * 32;
  227.         m = 2 * l;
  228.         if (val < -l) {
  229.             val += m;
  230.         } else if (val >= l) {
  231.             val -= m;
  232.         }
  234.         if (val >= 0) {
  235.             val--;
  236.             code = (val >> bit_size) + 1;
  237.             bits = val & (range - 1);
  238.             sign = 0;
  239.         } else {
  240.             val = -val;
  241.             val--;
  242.             code = (val >> bit_size) + 1;
  243.             bits = val & (range - 1);
  244.             sign = 1;
  245.         }
  247.         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 
  248.         if (bit_size > 0) {
  249.             put_bits(&s->pb, bit_size, bits);
  250.         }
  251.     }
  252. }
  255. #define CODE_INTRA(run, level, last)             
  256. {                                                       
  257.     if (last == 0) {                                    
  258.         if (run == 0 && level < 28) {                   
  259.             code = coeff_tab4[level - 1][0];            
  260.             len = coeff_tab4[level - 1][1];             
  261.         } else if (run == 1 && level < 11) {            
  262.             code = coeff_tab5[level - 1][0];            
  263.             len = coeff_tab5[level - 1][1];             
  264.         } else if (run > 1 && run < 10 && level < 6) {  
  265.             code = coeff_tab6[run - 2][level - 1][0];   
  266.             len = coeff_tab6[run - 2][level - 1][1];    
  267.         } else if (run > 9 && run < 15 && level == 1) { 
  268.             code = coeff_tab7[run - 10][0];             
  269.             len = coeff_tab7[run - 10][1];              
  270.         }                                               
  271.     } else {                                            
  272.         if (run == 0 && level < 9) {                    
  273.             code = coeff_tab8[level - 1][0];            
  274.             len = coeff_tab8[level - 1][1];             
  275.         } else if (run > 0 && run < 7 && level < 4) {   
  276.             code = coeff_tab9[run - 1][level - 1][0];   
  277.             len = coeff_tab9[run - 1][level - 1][1];    
  278.         } else if (run > 6 && run < 21 && level == 1) { 
  279.             code = coeff_tab10[run - 7][0];             
  280.             len = coeff_tab10[run - 7][1];              
  281.         }                                               
  282.     }                                                   
  283. }
  285. #define CODE_INTER(run, level, last)                     
  286. {                                                               
  287.     if (last == 0) {                                            
  288.         if (run < 2 && level < 13) {                            
  289.             len = coeff_tab0[run][level - 1][1];                
  290.             code = coeff_tab0[run][level - 1][0];               
  291.         } else if (run >= 2 && run < 27 && level < 5) {         
  292.             len = coeff_tab1[run - 2][level - 1][1];            
  293.             code = coeff_tab1[run - 2][level - 1][0];           
  294.         }                                                       
  295.     } else {                                                    
  296.         if (run < 2 && level < 4) {                             
  297.             len = coeff_tab2[run][level - 1][1];                
  298.             code = coeff_tab2[run][level - 1][0];               
  299.         } else if (run >= 2 && run < 42 && level == 1) {        
  300.             len = coeff_tab3[run - 2][1];                       
  301.             code = coeff_tab3[run - 2][0];                      
  302.         }                                                       
  303.     }                                                           
  304. }
  306. static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
  307. {
  308.     int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
  309.     int code = 0, len;
  311.     if (s->mb_intra) {
  312. /* DC coef */
  313. level = block[0];
  314. if (level == 128)
  315.     put_bits(&s->pb, 8, 0xff);
  316. else
  317.     put_bits(&s->pb, 8, level & 0xff);
  318. i = 1;
  319.     } else {
  320. i = 0;
  321.     }
  323.     /* AC coefs */
  324.     last_index = s->block_last_index[n];
  325.     last_non_zero = i - 1;
  326.     for (; i <= last_index; i++) {
  327. j = zigzag_direct[i];
  328. level = block[j];
  329. if (level) {
  330.     run = i - last_non_zero - 1;
  331.     last = (i == last_index);
  332.     sign = 0;
  333.     slevel = level;
  334.     if (level < 0) {
  335. sign = 1;
  336. level = -level;
  337.     }
  338.             len = 0;
  339.             CODE_INTER(run, level, last);
  340.             if (len == 0) {
  341.                 put_bits(&s->pb, 7, 3);
  342.                 put_bits(&s->pb, 1, last);
  343.                 put_bits(&s->pb, 6, run);
  344.                 put_bits(&s->pb, 8, slevel & 0xff);
  345.             } else {
  346.                 code = (code << 1) | sign;
  347.                 put_bits(&s->pb, len + 1, code);
  348.             }
  349.     last_non_zero = i;
  350. }
  351.     }
  352. }
  354. /* write RV 1.0 compatible frame header */
  355. void rv10_encode_picture_header(MpegEncContext * s, int picture_number)
  356. {
  357.     align_put_bits(&s->pb);
  359.     put_bits(&s->pb, 1, 1); /* marker */
  361.     put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
  363.     put_bits(&s->pb, 1, 0); /* not PB frame */
  365.     put_bits(&s->pb, 5, s->qscale);
  367.     if (s->pict_type == I_TYPE) {
  368. /* specific MPEG like DC coding not used */
  369.     }
  370.     /* if multiple packets per frame are sent, the position at which
  371.        to display the macro blocks is coded here */
  372.     put_bits(&s->pb, 6, 0); /* mb_x */
  373.     put_bits(&s->pb, 6, 0); /* mb_y */
  374.     put_bits(&s->pb, 12, s->mb_width * s->mb_height);
  376.     put_bits(&s->pb, 3, 0); /* ignored */
  377. }
  379. /***************************************************/
  381. /* write mpeg4 VOP header */
  382. void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
  383. {
  384.     align_put_bits(&s->pb);
  386.     put_bits(&s->pb, 32, 0x1B6); /* vop header */
  387.     put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
  388.     /* XXX: time base + 1 not always correct */
  389.     put_bits(&s->pb, 1, 1);
  390.     put_bits(&s->pb, 1, 0);
  392.     put_bits(&s->pb, 1, 1); /* marker */
  393.     put_bits(&s->pb, 4, 1); /* XXX: correct time increment */
  394.     put_bits(&s->pb, 1, 1); /* marker */
  395.     put_bits(&s->pb, 1, 1); /* vop coded */
  396.     if (s->pict_type == P_TYPE)
  397. put_bits(&s->pb, 1, 0); /* rounding type */
  398.     put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
  400.     put_bits(&s->pb, 5, s->qscale);
  402.     if (s->pict_type != I_TYPE)
  403. put_bits(&s->pb, 3, s->f_code); /* fcode_for */
  404. }
  406. void h263_dc_scale(MpegEncContext * s)
  407. {
  408.     int quant;
  410.     quant = s->qscale;
  411.     /* luminance */
  412.     if (quant < 5)
  413. s->y_dc_scale = 8;
  414.     else if (quant > 4 && quant < 9)
  415. s->y_dc_scale = (2 * quant);
  416.     else if (quant > 8 && quant < 25)
  417. s->y_dc_scale = (quant + 8);
  418.     else
  419. s->y_dc_scale = (2 * quant - 16);
  420.     /* chrominance */
  421.     if (quant < 5)
  422. s->c_dc_scale = 8;
  423.     else if (quant > 4 && quant < 25)
  424. s->c_dc_scale = ((quant + 13) / 2);
  425.     else
  426. s->c_dc_scale = (quant - 6);
  427. }
  429. static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
  430. {
  431.     int size, v, a, b, c, x, y, wrap, pred, scale;
  432.     UINT16 *dc_val;
  434.     /* find prediction */
  435.     if (n < 4) {
  436. x = 2 * s->mb_x + 1 + (n & 1);
  437. y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
  438. wrap = s->mb_width * 2 + 2;
  439. dc_val = s->dc_val[0];
  440. scale = s->y_dc_scale;
  441.     } else {
  442. x = s->mb_x + 1;
  443. y = s->mb_y + 1;
  444. wrap = s->mb_width + 2;
  445. dc_val = s->dc_val[n - 4 + 1];
  446. scale = s->c_dc_scale;
  447.     }
  449.     /* B C
  450.      * A X 
  451.      */
  452.     a = dc_val[(x - 1) + (y) * wrap];
  453.     b = dc_val[(x - 1) + (y - 1) * wrap];
  454.     c = dc_val[(x) + (y - 1) * wrap];
  456.     if (abs(a - b) < abs(b - c)) {
  457. pred = c;
  458.     } else {
  459. pred = a;
  460.     }
  461.     /* we assume pred is positive */
  462.     pred = (pred + (scale >> 1)) / scale;
  464.     /* update predictor */
  465.     dc_val[(x) + (y) * wrap] = level * scale;
  467.     /* do the prediction */
  468.     level -= pred;
  470.     /* find number of bits */
  471.     size = 0;
  472.     v = abs(level);
  473.     while (v) {
  474. v >>= 1;
  475. size++;
  476.     }
  478.     if (n < 4) {
  479. /* luminance */
  480. put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
  481.     } else {
  482. /* chrominance */
  483. put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
  484.     }
  486.     /* encode remaining bits */
  487.     if (size > 0) {
  488. if (level < 0)
  489.     level = (-level) ^ ((1 << size) - 1);
  490. put_bits(&s->pb, size, level);
  491. if (size > 8)
  492.     put_bits(&s->pb, 1, 1);
  493.     }
  494. }
  496. static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
  497. {
  498.     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, level1, run1;
  499.     int code = 0, len;
  501.     if (s->mb_intra) {
  502. /* mpeg4 based DC predictor */
  503. mpeg4_encode_dc(s, block[0], n);
  504. i = 1;
  505.     } else {
  506. i = 0;
  507.     }
  509.     /* AC coefs */
  510.     last_index = s->block_last_index[n];
  511.     last_non_zero = i - 1;
  512.     for (; i <= last_index; i++) {
  513. j = zigzag_direct[i];
  514. level = block[j];
  515. if (level) {
  516.     run = i - last_non_zero - 1;
  517.     last = (i == last_index);
  518.     sign = 0;
  519.     slevel = level;
  520.     if (level < 0) {
  521. sign = 1;
  522. level = -level;
  523.     }
  524.             len = 0;
  525.     if (s->mb_intra) {
  526. /* intra mb */
  527.                 CODE_INTRA(run, level, last);
  528.                 if (len)
  529.                     goto esc0;
  530.                 /* first escape */
  531.                 level1 = level - intra_max_level[last][run];
  532.                 assert(level1 >= 0);
  533.                 if (level1 < 28) {
  534.                     CODE_INTRA(run, level1, last);
  535.                     if (len)
  536.                         goto esc1;
  537.                 }
  538.                 /* second escape */
  539.                 run1 = run - (intra_max_run[last][level]+1);
  540.                 if (level < 28 && run1 >= 0) {
  541.                     CODE_INTRA(run1, level, last);
  542.                     if (len)
  543.                         goto esc2;
  544.                 }
  545.     } else {
  546. /* inter mb */
  547.                 CODE_INTER(run, level, last);
  548.                 if (len)
  549.                     goto esc0;
  550.                 /* first escape */
  551.                 level1 = level - inter_max_level[last][run];
  552.                 assert(level1 >= 0);
  553.                 if (level1 < 13) {
  554.                     CODE_INTER(run, level1, last);
  555.                     if (len)
  556.                         goto esc1;
  557.                 }
  558.                 /* second escape */
  559.                 run1 = run - (inter_max_run[last][level]+1);
  560.                 if (level < 13 && run1 >= 0) {
  561.                     CODE_INTER(run1, level, last);
  562.                     if (len)
  563.                         goto esc2;
  564.                 }
  565.             }
  566.             /* third escape */
  567.             put_bits(&s->pb, 7, 3);
  568.             put_bits(&s->pb, 2, 3);
  569.             put_bits(&s->pb, 1, last);
  570.             put_bits(&s->pb, 6, run);
  571.             put_bits(&s->pb, 1, 1); /* marker */
  572.             put_bits(&s->pb, 12, slevel & 0xfff);
  573.             put_bits(&s->pb, 1, 1); /* marker */
  574.             goto next;
  575.         esc2:
  576.             put_bits(&s->pb, 7, 3);
  577.             put_bits(&s->pb, 2, 2);
  578.             goto esc0;
  579.         esc1:
  580.             put_bits(&s->pb, 7, 3);
  581.             put_bits(&s->pb, 1, 0);
  582.         esc0:
  583.             code = (code << 1) | sign;
  584.             put_bits(&s->pb, len + 1, code);
  585.         next:
  586.     last_non_zero = i;
  587. }
  588.     }
  589. }