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

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

流媒体/Mpeg4/MP4

开发平台：

Unix_Linux

mpegvideo.c：源码内容
  1. /*
  2.  * The simplest mpeg 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 <math.h>
  23. #include "avcodec.h"
  24. #include "dsputil.h"
  25. #include "mpegvideo.h"
  27. /* enable all paranoid tests for rounding, overflows, etc... */
  28. //#define PARANOID
  30. //#define DEBUG
  32. /* for jpeg fast DCT */
  33. #define CONST_BITS 14
  35. static const unsigned short aanscales[64] = {
  36.     /* precomputed values scaled up by 14 bits */
  37.     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  38.     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  39.     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  40.     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  41.     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  42.     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  43.     8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  44.     4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  45. };
  47. static void encode_picture(MpegEncContext *s, int picture_number);
  48. static void rate_control_init(MpegEncContext *s);
  49. static int rate_estimate_qscale(MpegEncContext *s);
  50. static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
  52. #include "mpegencodevlc.h"
  54. static void put_header(MpegEncContext *s, int header)
  55. {
  56.     align_put_bits(&s->pb);
  57.     put_bits(&s->pb, 32, header);
  58. }
  60. static void convert_matrix(int *qmat, const UINT8 *quant_matrix, int qscale)
  61. {
  62.     int i;
  64.     for(i=0;i<64;i++) {
  65.         qmat[i] = (int)((1 << 22) * 16384.0 / (aanscales[i] * qscale * quant_matrix[i]));
  66.     }
  67. }
  70. int MPV_encode_init(AVEncodeContext *avctx)
  71. {
  72.     MpegEncContext *s = avctx->priv_data;
  73.     int pict_size, c_size;
  74.     UINT8 *pict;
  76.     dsputil_init();
  78.     s->bit_rate = avctx->bit_rate;
  79.     s->frame_rate = avctx->rate;
  80.     s->width = avctx->width;
  81.     s->height = avctx->height;
  82.     s->gop_size = avctx->gop_size;
  83.     if (s->gop_size <= 1) {
  84.         s->intra_only = 1;
  85.         s->gop_size = 12;
  86.     } else {
  87.         s->intra_only = 0;
  88.     }
  89.     s->full_search = 0;
  90.     if (avctx->flags & CODEC_FLAG_HQ)
  91.         s->full_search = 1;
  93.     switch(avctx->codec->id) {
  94.     case CODEC_ID_MPEG1VIDEO:
  95.         s->out_format = FMT_MPEG1;
  96.         break;
  97.     case CODEC_ID_MJPEG:
  98.         s->out_format = FMT_MJPEG;
  99.         s->intra_only = 1; /* force intra only for jpeg */
  100.         if (mjpeg_init(s) < 0)
  101.             return -1;
  102.         break;
  103.     case CODEC_ID_H263:
  104.         s->out_format = FMT_H263;
  105.         break;
  106.     case CODEC_ID_RV10:
  107.         s->out_format = FMT_H263;
  108.         s->h263_rv10 = 1;
  109.         break;
  110.     case CODEC_ID_DIVX:
  111.         s->out_format = FMT_H263;
  112.         s->h263_pred = 1;
  113.         break;
  114.     default:
  115.         return -1;
  116.     }
  118.     switch(s->frame_rate) {
  119.     case 24:
  120.         s->frame_rate_index = 2;
  121.         break;
  122.     case 25:
  123.         s->frame_rate_index = 3;
  124.         break;
  125.     case 30:
  126.         s->frame_rate_index = 5;
  127.         break;
  128.     case 50:
  129.         s->frame_rate_index = 6;
  130.         break;
  131.     case 60:
  132.         s->frame_rate_index = 8;
  133.         break;
  134.     default:
  135.         /* we accept lower frame rates than 24 for low bit rate mpeg */
  136.         if (s->frame_rate >= 1 && s->frame_rate < 24) {
  137.             s->frame_rate_index = 2;
  138.         } else {
  139.             return -1;
  140.         }
  141.         break;
  142.     }
  144.     /* init */
  145.     s->mb_width = s->width / 16;
  146.     s->mb_height = s->height / 16;
  147.     
  148.     c_size = s->width * s->height;
  149.     pict_size = (c_size * 3) / 2;
  150.     pict = malloc(pict_size);
  151.     if (pict == NULL)
  152.         goto fail;
  153.     s->last_picture[0] = pict;
  154.     s->last_picture[1] = pict + c_size;
  155.     s->last_picture[2] = pict + c_size + (c_size / 4);
  156.     
  157.     pict = malloc(pict_size);
  158.     if (pict == NULL) 
  159.         goto fail;
  160.     s->current_picture[0] = pict;
  161.     s->current_picture[1] = pict + c_size;
  162.     s->current_picture[2] = pict + c_size + (c_size / 4);
  164.     if (s->out_format == FMT_H263) {
  165.         int size;
  166.         /* MV prediction */
  167.         size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
  168.         s->motion_val = malloc(size * 2 * sizeof(INT16));
  169.         if (s->motion_val == NULL)
  170.             goto fail;
  171.         memset(s->motion_val, 0, size * 2 * sizeof(INT16));
  172.     }
  174.     if (s->h263_pred) {
  175.         int y_size, c_size, i, size;
  177.         y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
  178.         c_size = (s->mb_width + 2) * (s->mb_height + 2);
  179.         size = y_size + 2 * c_size;
  180.         s->dc_val[0] = malloc(size * sizeof(INT16));
  181.         if (s->dc_val[0] == NULL)
  182.             goto fail;
  183.         s->dc_val[1] = s->dc_val[0] + y_size;
  184.         s->dc_val[2] = s->dc_val[1] + c_size;
  185.         for(i=0;i<size;i++)
  186.             s->dc_val[0][i] = 1024;
  187.     }
  189.     /* rate control init */
  190.     rate_control_init(s);
  192.     s->picture_number = 0;
  193.     s->fake_picture_number = 0;
  194.     /* motion detector init */
  195.     s->f_code = 1;
  197.     return 0;
  198.  fail:
  199.     if (s->motion_val)
  200.         free(s->motion_val);
  201.     if (s->dc_val[0])
  202.         free(s->dc_val[0]);
  203.     if (s->last_picture[0])
  204.         free(s->last_picture[0]);
  205.     if (s->current_picture[0])
  206.         free(s->current_picture[0]);
  207.     return -1;
  208. }
  210. int MPV_encode_end(AVEncodeContext *avctx)
  211. {
  212.     MpegEncContext *s = avctx->priv_data;
  213. #if 0
  214.     /* end of sequence */
  215.     if (s->out_format == FMT_MPEG1) {
  216.         put_header(s, SEQ_END_CODE);
  217.     }
  219.     if (!s->flush_frames)
  220.         flush_put_bits(&s->pb);
  221. #endif    
  222.     if (s->motion_val)
  223.         free(s->motion_val);
  224.     if (s->h263_pred)
  225.         free(s->dc_val[0]);
  226.     free(s->last_picture[0]);
  227.     free(s->current_picture[0]);
  228.     if (s->out_format == FMT_MJPEG)
  229.         mjpeg_close(s);
  230.     return 0;
  231. }
  233. int MPV_encode_picture(AVEncodeContext *avctx,
  234.                        unsigned char *buf, int buf_size, void *data)
  235. {
  236.     MpegEncContext *s = avctx->priv_data;
  237.     int i;
  239.     memcpy(s->new_picture, data, 3 * sizeof(UINT8 *));
  241.     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
  243.     /* group of picture */
  244.     if (s->out_format == FMT_MPEG1) {
  245.         unsigned int vbv_buffer_size;
  246.         unsigned int time_code, fps, n;
  248.         if ((s->picture_number % s->gop_size) == 0) {
  249.             /* mpeg1 header repeated every gop */
  250.             put_header(s, SEQ_START_CODE);
  251.             
  252.             put_bits(&s->pb, 12, s->width);
  253.             put_bits(&s->pb, 12, s->height);
  254.             put_bits(&s->pb, 4, 1); /* 1/1 aspect ratio */
  255.             put_bits(&s->pb, 4, s->frame_rate_index);
  256.             put_bits(&s->pb, 18, 0x3ffff);
  257.             put_bits(&s->pb, 1, 1); /* marker */
  258.             /* vbv buffer size: slightly greater than an I frame. We add
  259.                some margin just in case */
  260.             vbv_buffer_size = (3 * s->I_frame_bits) / (2 * 8);
  261.             put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384); 
  262.             put_bits(&s->pb, 1, 1); /* constrained parameter flag */
  263.             put_bits(&s->pb, 1, 0); /* no custom intra matrix */
  264.             put_bits(&s->pb, 1, 0); /* no custom non intra matrix */
  266.             put_header(s, GOP_START_CODE);
  267.             put_bits(&s->pb, 1, 0); /* do drop frame */
  268.             /* time code : we must convert from the real frame rate to a
  269.                fake mpeg frame rate in case of low frame rate */
  270.             fps = frame_rate_tab[s->frame_rate_index];
  271.             time_code = s->fake_picture_number;
  272.             s->gop_picture_number = time_code;
  273.             put_bits(&s->pb, 5, (time_code / (fps * 3600)) % 24);
  274.             put_bits(&s->pb, 6, (time_code / (fps * 60)) % 60);
  275.             put_bits(&s->pb, 1, 1);
  276.             put_bits(&s->pb, 6, (time_code / fps) % 60);
  277.             put_bits(&s->pb, 6, (time_code % fps));
  278.             put_bits(&s->pb, 1, 1); /* closed gop */
  279.             put_bits(&s->pb, 1, 0); /* broken link */
  280.         }
  282.         if (s->frame_rate < 24 && s->picture_number > 0) {
  283.             /* insert empty P pictures to slow down to the desired
  284.                frame rate. Each fake pictures takes about 20 bytes */
  285.             fps = frame_rate_tab[s->frame_rate_index];
  286.             n = ((s->picture_number * fps) / s->frame_rate) - 1;
  287.             while (s->fake_picture_number < n) {
  288.                 mpeg1_skip_picture(s, s->fake_picture_number - 
  289.                                    s->gop_picture_number); 
  290.                 s->fake_picture_number++;
  291.             }
  293.         }
  294.         s->fake_picture_number++;
  295.     }
  296.     
  297.     
  298.     if (!s->intra_only) {
  299.         /* first picture of GOP is intra */
  300.         if ((s->picture_number % s->gop_size) == 0)
  301.             s->pict_type = I_TYPE;
  302.         else
  303.             s->pict_type = P_TYPE;
  304.     } else {
  305.         s->pict_type = I_TYPE;
  306.     }
  307.     avctx->key_frame = (s->pict_type == I_TYPE);
  308.     
  309.     encode_picture(s, s->picture_number);
  310.     
  311.     /* swap current and last picture */
  312.     for(i=0;i<3;i++) {
  313.         UINT8 *tmp;
  314.         
  315.         tmp = s->last_picture[i];
  316.         s->last_picture[i] = s->current_picture[i];
  317.         s->current_picture[i] = tmp;
  318.     }
  319.     s->picture_number++;
  321.     if (s->out_format == FMT_MJPEG)
  322.         mjpeg_picture_trailer(s);
  324.     flush_put_bits(&s->pb);
  325.     s->total_bits += (s->pb.buf_ptr - s->pb.buf) * 8;
  326.     avctx->quality = s->qscale;
  327.     return s->pb.buf_ptr - s->pb.buf;
  328. }
  330. /* insert a fake P picture */
  331. static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
  332. {
  333.     unsigned int mb_incr;
  335.     /* mpeg1 picture header */
  336.     put_header(s, PICTURE_START_CODE);
  337.     /* temporal reference */
  338.     put_bits(&s->pb, 10, pict_num & 0x3ff); 
  339.     
  340.     put_bits(&s->pb, 3, P_TYPE);
  341.     put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
  342.     
  343.     put_bits(&s->pb, 1, 1); /* integer coordinates */
  344.     put_bits(&s->pb, 3, 1); /* forward_f_code */
  345.     
  346.     put_bits(&s->pb, 1, 0); /* extra bit picture */
  347.     
  348.     /* only one slice */
  349.     put_header(s, SLICE_MIN_START_CODE);
  350.     put_bits(&s->pb, 5, 1); /* quantizer scale */
  351.     put_bits(&s->pb, 1, 0); /* slice extra information */
  352.     
  353.     mb_incr = 1;
  354.     put_bits(&s->pb, mbAddrIncrTable[mb_incr][1], 
  355.              mbAddrIncrTable[mb_incr][0]);
  356.     
  357.     /* empty macroblock */
  358.     put_bits(&s->pb, 3, 1); /* motion only */
  359.     
  360.     /* zero motion x & y */
  361.     put_bits(&s->pb, 1, 1); 
  362.     put_bits(&s->pb, 1, 1); 
  364.     /* output a number of empty slice */
  365.     mb_incr = s->mb_width * s->mb_height - 1;
  366.     while (mb_incr > 33) {
  367.         put_bits(&s->pb, 11, 0x008);
  368.         mb_incr -= 33;
  369.     }
  370.     put_bits(&s->pb, mbAddrIncrTable[mb_incr][1], 
  371.              mbAddrIncrTable[mb_incr][0]);
  372.     
  373.     /* empty macroblock */
  374.     put_bits(&s->pb, 3, 1); /* motion only */
  375.     
  376.     /* zero motion x & y */
  377.     put_bits(&s->pb, 1, 1); 
  378.     put_bits(&s->pb, 1, 1); 
  379. }
  381. static int dct_quantize(MpegEncContext *s, DCTELEM *block, int n, int qscale);
  382. static void encode_block(MpegEncContext *s, 
  383.                          DCTELEM *block, 
  384.                          int component);
  385. static void dct_unquantize(MpegEncContext *s, DCTELEM *block, int n, int qscale);
  386. static void mpeg1_encode_mb(MpegEncContext *s, int mb_x, int mb_y,
  387.                             DCTELEM block[6][64],
  388.                             int motion_x, int motion_y);
  390. static void encode_picture(MpegEncContext *s, int picture_number)
  391. {
  392.     int mb_x, mb_y;
  393.     UINT8 *ptr;
  394.     DCTELEM block[6][64];
  395.     int i, motion_x, motion_y;
  397.     s->picture_number = picture_number;
  398. #if 1
  399.     s->qscale = rate_estimate_qscale(s);
  400. #else
  401.     s->qscale = 10;
  402. #endif
  403.     /* precompute matrix */
  404.     if (s->out_format == FMT_MJPEG) {
  405.         /* for mjpeg, we do include qscale in the matrix */
  406.         s->init_intra_matrix[0] = default_intra_matrix[0];
  407.         for(i=1;i<64;i++)
  408.             s->init_intra_matrix[i] = (default_intra_matrix[i] * s->qscale) >> 3;
  409.         convert_matrix(s->intra_matrix, s->init_intra_matrix, 8);
  410.     } else {
  411.         convert_matrix(s->intra_matrix, default_intra_matrix, s->qscale);
  412.         convert_matrix(s->non_intra_matrix, default_non_intra_matrix, s->qscale);
  413.     }
  415.     switch(s->out_format) {
  416.     case FMT_MJPEG:
  417.         mjpeg_picture_header(s);
  418.         break;
  419.     case FMT_H263:
  420.         if (s->h263_pred) 
  421.             mpeg4_encode_picture_header(s, picture_number);
  422.         else if (s->h263_rv10) 
  423.             rv10_encode_picture_header(s, picture_number);
  424.         else
  425.             h263_picture_header(s, picture_number);
  426.         break;
  427.     case FMT_MPEG1:
  428.         /* mpeg1 picture header */
  429.         put_header(s, PICTURE_START_CODE);
  430.         /* temporal reference */
  431.         put_bits(&s->pb, 10, (s->fake_picture_number - 
  432.                               s->gop_picture_number) & 0x3ff); 
  433.         
  434.         put_bits(&s->pb, 3, s->pict_type);
  435.         put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
  436.         
  437.         if (s->pict_type == P_TYPE) {
  438.             put_bits(&s->pb, 1, 0); /* half pel coordinates */
  439.             put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
  440.         }
  441.         
  442.         put_bits(&s->pb, 1, 0); /* extra bit picture */
  443.         
  444.         /* only one slice */
  445.         put_header(s, SLICE_MIN_START_CODE);
  446.         put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
  447.         put_bits(&s->pb, 1, 0); /* slice extra information */
  448.         break;
  449.     }
  450.         
  451.     /* init last dc values */
  452.     /* note: quant matrix value (8) is implied here */
  453.     s->last_dc[0] = 128;
  454.     s->last_dc[1] = 128;
  455.     s->last_dc[2] = 128;
  456.     s->mb_incr = 1;
  457.     s->last_motion_x = 0;
  458.     s->last_motion_y = 0;
  460.     for(mb_y=0; mb_y < s->mb_height; mb_y++) {
  461.         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
  463.             s->mb_x = mb_x;
  464.             s->mb_y = mb_y;
  466.             /* compute motion vector and macro block type (intra or non intra) */
  467.             motion_x = 0;
  468.             motion_y = 0;
  469.             if (s->pict_type == P_TYPE) {
  470.                 s->mb_intra = estimate_motion(s, mb_x, mb_y,
  471.                                               &motion_x,
  472.                                               &motion_y);
  473.             } else {
  474.                 s->mb_intra = 1;
  475.             }
  477.             /* get the pixels */
  478.             ptr = s->new_picture[0] + (mb_y * 16 * s->width) + mb_x * 16;
  479.             get_pixels(block[0], ptr, s->width);
  480.             get_pixels(block[1], ptr + 8, s->width);
  481.             get_pixels(block[2], ptr + 8 * s->width, s->width);
  482.             get_pixels(block[3], ptr + 8 * s->width + 8, s->width);
  483.             ptr = s->new_picture[1] + (mb_y * 8 * (s->width >> 1)) + mb_x * 8;
  484.             get_pixels(block[4],ptr, s->width >> 1);
  486.             ptr = s->new_picture[2] + (mb_y * 8 * (s->width >> 1)) + mb_x * 8;
  487.             get_pixels(block[5],ptr, s->width >> 1);
  489.             /* subtract previous frame if non intra */
  490.             if (!s->mb_intra) {
  491.                 int dxy, offset, mx, my;
  493.                 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
  494.                 ptr = s->last_picture[0] + 
  495.                     ((mb_y * 16 + (motion_y >> 1)) * s->width) + 
  496.                     (mb_x * 16 + (motion_x >> 1));
  498.                 sub_pixels_2(block[0], ptr, s->width, dxy);
  499.                 sub_pixels_2(block[1], ptr + 8, s->width, dxy);
  500.                 sub_pixels_2(block[2], ptr + s->width * 8, s->width, dxy);
  501.                 sub_pixels_2(block[3], ptr + 8 + s->width * 8, s->width ,dxy);
  503.                 if (s->out_format == FMT_H263) {
  504.                     /* special rounding for h263 */
  505.                     dxy = 0;
  506.                     if ((motion_x & 3) != 0)
  507.                         dxy |= 1;
  508.                     if ((motion_y & 3) != 0)
  509.                         dxy |= 2;
  510.                     mx = motion_x >> 2;
  511.                     my = motion_y >> 2;
  512.                 } else {
  513.                     mx = motion_x / 2;
  514.                     my = motion_y / 2;
  515.                     dxy = ((my & 1) << 1) | (mx & 1);
  516.                     mx >>= 1;
  517.                     my >>= 1;
  518.                 }
  519.                 offset = ((mb_y * 8 + my) * (s->width >> 1)) + (mb_x * 8 + mx);
  520.                 ptr = s->last_picture[1] + offset;
  521.                 sub_pixels_2(block[4], ptr, s->width >> 1, dxy);
  522.                 ptr = s->last_picture[2] + offset;
  523.                 sub_pixels_2(block[5], ptr, s->width >> 1, dxy);
  524.             }
  526.             /* DCT & quantize */
  527.             if (s->h263_pred) {
  528.                 h263_dc_scale(s);
  529.             } else {
  530.                 /* default quantization values */
  531.                 s->y_dc_scale = 8;
  532.                 s->c_dc_scale = 8;
  533.             }
  535.             for(i=0;i<6;i++) {
  536.                 int last_index;
  537.                 last_index = dct_quantize(s, block[i], i, s->qscale);
  538.                 s->block_last_index[i] = last_index;
  539.             }
  541.             /* huffman encode */
  542.             switch(s->out_format) {
  543.             case FMT_MPEG1:
  544.                 mpeg1_encode_mb(s, mb_x, mb_y, block, motion_x, motion_y);
  545.                 break;
  546.             case FMT_H263:
  547.                 h263_encode_mb(s, block, motion_x, motion_y);
  548.                 break;
  549.             case FMT_MJPEG:
  550.                 mjpeg_encode_mb(s, block);
  551.                 break;
  552.             }
  554.             /* update DC predictors for P macroblocks */
  555.             if (!s->mb_intra) {
  556.                 if (s->h263_pred) {
  557.                     int wrap, x, y;
  558.                     wrap = 2 * s->mb_width + 2;
  559.                     x = 2 * mb_x + 1;
  560.                     y = 2 * mb_y + 1;
  561.                     s->dc_val[0][(x) + (y) * wrap] = 1024;
  562.                     s->dc_val[0][(x + 1) + (y) * wrap] = 1024;
  563.                     s->dc_val[0][(x) + (y + 1) * wrap] = 1024;
  564.                     s->dc_val[0][(x + 1) + (y + 1) * wrap] = 1024;
  565.                     wrap = s->mb_width + 2;
  566.                     x = mb_x + 1;
  567.                     y = mb_y + 1;
  568.                     s->dc_val[1][(x) + (y) * wrap] = 1024;
  569.                     s->dc_val[2][(x) + (y) * wrap] = 1024;
  570.                 } else {
  571.                     s->last_dc[0] = 128;
  572.                     s->last_dc[1] = 128;
  573.                     s->last_dc[2] = 128;
  574.                 }
  575.             }
  577.             /* update motion predictor */
  578.             if (s->out_format == FMT_H263) {
  579.                 int x, y, wrap;
  580.                 
  581.                 x = 2 * mb_x + 1;
  582.                 y = 2 * mb_y + 1;
  583.                 wrap = 2 * s->mb_width + 2;
  584.                 s->motion_val[(x) + (y) * wrap][0] = motion_x;
  585.                 s->motion_val[(x) + (y) * wrap][1] = motion_y;
  586.                 s->motion_val[(x + 1) + (y) * wrap][0] = motion_x;
  587.                 s->motion_val[(x + 1) + (y) * wrap][1] = motion_y;
  588.                 s->motion_val[(x) + (y + 1) * wrap][0] = motion_x;
  589.                 s->motion_val[(x) + (y + 1) * wrap][1] = motion_y;
  590.                 s->motion_val[(x + 1) + (y + 1) * wrap][0] = motion_x;
  591.                 s->motion_val[(x + 1) + (y + 1) * wrap][1] = motion_y;
  592.             } else {
  593.                 s->last_motion_x = motion_x;
  594.                 s->last_motion_y = motion_y;
  595.             }
  596.             
  597.             /* decompress blocks so that we keep the state of the decoder */
  598.             if (!s->intra_only) {
  599.                 for(i=0;i<6;i++) {
  600.                     if (s->block_last_index[i] >= 0) {
  601.                         dct_unquantize(s, block[i], i, s->qscale);
  602.                         j_rev_dct (block[i]);
  603.                     }
  604.                 }
  606.                 if (!s->mb_intra) {
  607.                     int dxy, offset, mx, my;
  608.                     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
  609.                     ptr = s->last_picture[0] + 
  610.                         ((mb_y * 16 + (motion_y >> 1)) * s->width) + 
  611.                         (mb_x * 16 + (motion_x >> 1));
  612.                     
  613.                     add_pixels_2(block[0], ptr, s->width, dxy);
  614.                     add_pixels_2(block[1], ptr + 8, s->width, dxy);
  615.                     add_pixels_2(block[2], ptr + s->width * 8, s->width, dxy);
  616.                     add_pixels_2(block[3], ptr + 8 + s->width * 8, s->width, dxy);
  618.                     if (s->out_format == FMT_H263) {
  619.                         /* special rounding for h263 */
  620.                         dxy = 0;
  621.                         if ((motion_x & 3) != 0)
  622.                             dxy |= 1;
  623.                         if ((motion_y & 3) != 0)
  624.                             dxy |= 2;
  625.                         mx = motion_x >> 2;
  626.                         my = motion_y >> 2;
  627.                     } else {
  628.                         mx = motion_x / 2;
  629.                         my = motion_y / 2;
  630.                         dxy = ((my & 1) << 1) | (mx & 1);
  631.                         mx >>= 1;
  632.                         my >>= 1;
  633.                     }
  634.                     offset = ((mb_y * 8 + my) * (s->width >> 1)) + (mb_x * 8 + mx);
  635.                     ptr = s->last_picture[1] + offset;
  636.                     add_pixels_2(block[4], ptr, s->width >> 1, dxy);
  637.                     ptr = s->last_picture[2] + offset;
  638.                     add_pixels_2(block[5], ptr, s->width >> 1, dxy);
  639.                 }
  641.                 /* write the pixels */
  642.                 ptr = s->current_picture[0] + (mb_y * 16 * s->width) + mb_x * 16;
  643.                 put_pixels(block[0], ptr, s->width);
  644.                 put_pixels(block[1], ptr + 8, s->width);
  645.                 put_pixels(block[2], ptr + 8 * s->width, s->width);
  646.                 put_pixels(block[3], ptr + 8 * s->width + 8, s->width);
  647.                 ptr = s->current_picture[1] + (mb_y * 8 * (s->width >> 1)) + mb_x * 8;
  648.                 put_pixels(block[4],ptr, s->width >> 1);
  649.                 
  650.                 ptr = s->current_picture[2] + (mb_y * 8 * (s->width >> 1)) + mb_x * 8;
  651.                 put_pixels(block[5],ptr, s->width >> 1);
  652.             }
  653.         }
  654.     }
  655. }
  657. static void mpeg1_encode_motion(MpegEncContext *s, int val)
  658. {
  659.     int code, bit_size, l, m, bits, range;
  661.     if (val == 0) {
  662.         /* zero vector */
  663.         code = 0;
  664.         put_bits(&s->pb,
  665.                  mbMotionVectorTable[code + 16][1], 
  666.                  mbMotionVectorTable[code + 16][0]); 
  667.     } else {
  668.         bit_size = s->f_code - 1;
  669.         range = 1 << bit_size;
  670.         /* modulo encoding */
  671.         l = 16 * range;
  672.         m = 2 * l;
  673.         if (val < -l) {
  674.             val += m;
  675.         } else if (val >= l) {
  676.             val -= m;
  677.         }
  679.         if (val >= 0) {
  680.             val--;
  681.             code = (val >> bit_size) + 1;
  682.             bits = val & (range - 1);
  683.         } else {
  684.             val = -val;
  685.             val--;
  686.             code = (val >> bit_size) + 1;
  687.             bits = val & (range - 1);
  688.             code = -code;
  689.         }
  690.         put_bits(&s->pb,
  691.                  mbMotionVectorTable[code + 16][1], 
  692.                  mbMotionVectorTable[code + 16][0]); 
  693.         if (bit_size > 0) {
  694.             put_bits(&s->pb, bit_size, bits);
  695.         }
  696.     }
  697. }
  699. static void mpeg1_encode_mb(MpegEncContext *s, int mb_x, int mb_y,
  700.                             DCTELEM block[6][64],
  701.                             int motion_x, int motion_y)
  702. {
  703.     int mb_incr, i, cbp;
  705.     /* compute cbp */
  706.     cbp = 0;
  707.     for(i=0;i<6;i++) {
  708.         if (s->block_last_index[i] >= 0)
  709.             cbp |= 1 << (5 - i);
  710.     }
  712.     /* skip macroblock, except if first or last macroblock of a slice */
  713.     if ((cbp | motion_x | motion_y) == 0 &&
  714.         (!((mb_x | mb_y) == 0 ||
  715.            (mb_x == s->mb_width - 1 && mb_y == s->mb_height - 1)))) {
  716.         s->mb_incr++;
  717.     } else {
  718.         /* output mb incr */
  719.         mb_incr = s->mb_incr;
  721.         while (mb_incr > 33) {
  722.             put_bits(&s->pb, 11, 0x008);
  723.             mb_incr -= 33;
  724.         }
  725.         put_bits(&s->pb, mbAddrIncrTable[mb_incr][1], 
  726.                  mbAddrIncrTable[mb_incr][0]);
  727.         
  728.         if (s->pict_type == I_TYPE) {
  729.             put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
  730.         } else {
  731.             if (s->mb_intra) {
  732.                 put_bits(&s->pb, 5, 0x03);
  733.             } else {
  734.                 if (cbp != 0) {
  735.                     if (motion_x == 0 && motion_y == 0) {
  736.                         put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
  737.                         put_bits(&s->pb, mbPatTable[cbp][1], mbPatTable[cbp][0]);
  738.                     } else {
  739.                         put_bits(&s->pb, 1, 1); /* motion + cbp */
  740.                         mpeg1_encode_motion(s, motion_x - s->last_motion_x); 
  741.                         mpeg1_encode_motion(s, motion_y - s->last_motion_y); 
  742.                         put_bits(&s->pb, mbPatTable[cbp][1], mbPatTable[cbp][0]);
  743.                     }
  744.                 } else {
  745.                     put_bits(&s->pb, 3, 1); /* motion only */
  746.                     mpeg1_encode_motion(s, motion_x - s->last_motion_x); 
  747.                     mpeg1_encode_motion(s, motion_y - s->last_motion_y); 
  748.                 }
  749.             }
  750.         }
  751.         
  752.         for(i=0;i<6;i++) {
  753.             if (cbp & (1 << (5 - i))) {
  754.                 encode_block(s, block[i], i);
  755.             }
  756.         }
  757.         s->mb_incr = 1;
  758.     }
  759. }
  761. static int dct_quantize(MpegEncContext *s, 
  762.                         DCTELEM *block, int n,
  763.                         int qscale)
  764. {
  765.     int i, j, level, last_non_zero, q;
  766.     const int *qmat;
  768.     jpeg_fdct_ifast (block);
  770.     if (s->mb_intra) {
  771.         if (n < 4)
  772.             q = s->y_dc_scale;
  773.         else
  774.             q = s->c_dc_scale;
  775.         q = q << 3;
  776.         
  777.         /* note: block[0] is assumed to be positive */
  778.         block[0] = (block[0] + (q >> 1)) / q;
  779.         i = 1;
  780.         last_non_zero = 0;
  781.         if (s->out_format == FMT_H263) {
  782.             qmat = s->non_intra_matrix;
  783.         } else {
  784.             qmat = s->intra_matrix;
  785.         }
  786.     } else {
  787.         i = 0;
  788.         last_non_zero = -1;
  789.         qmat = s->non_intra_matrix;
  790.     }
  792.     for(;i<64;i++) {
  793.         j = zigzag_direct[i];
  794.         level = block[j];
  795.         /* XXX: overflow can occur here at qscale < 3 */
  796.         level = level * qmat[j];
  797. #ifdef PARANOID
  798.         {
  799.             int level1;
  800.             level1 = ((long long)block[j] * (long long)(qmat[j]));
  801.             if (level1 != level)
  802.                 fprintf(stderr, "quant error %d %dn", level, level1);
  803.         }
  804. #endif
  805.         /* XXX: slight error for the low range */
  806.         //if (level <= -(1 << 22) || level >= (1 << 22)) 
  807.         if (((level << 9) >> 9) != level) {
  808.             level = level / (1 << 22);
  809.             /* XXX: currently, this code is not optimal. the range should be:
  810.                mpeg1: -255..255
  811.                mpeg2: -2048..2047
  812.                h263:  -128..127
  813.                mpeg4: -2048..2047
  814.             */
  815.             if (level > 127)
  816.                 level = 127;
  817.             else if (level < -128)
  818.                 level = -128;
  819.             block[j] = level;
  820.             last_non_zero = i;
  821.         } else {
  822.             block[j] = 0;
  823.         }
  824.     }
  825.     return last_non_zero;
  826. }
  828. static void dct_unquantize(MpegEncContext *s, 
  829.                            DCTELEM *block, int n, int qscale)
  830. {
  831.     int i, level;
  832.     const UINT8 *quant_matrix;
  834.     if (s->mb_intra) {
  835.         if (n < 4) 
  836.             block[0] = block[0] * s->y_dc_scale;
  837.         else
  838.             block[0] = block[0] * s->c_dc_scale;
  839.         if (s->out_format == FMT_H263) {
  840.             i = 1;
  841.             goto unquant_even;
  842.         }
  843.         quant_matrix = default_intra_matrix;
  844.         for(i=1;i<64;i++) {
  845.             level = block[i];
  846.             if (level) {
  847.                 if (level < 0) {
  848.                     level = -level;
  849.                     level = (int)(level * qscale * quant_matrix[i]) >> 3;
  850.                     level = (level - 1) | 1;
  851.                     level = -level;
  852.                 } else {
  853.                     level = (int)(level * qscale * quant_matrix[i]) >> 3;
  854.                     level = (level - 1) | 1;
  855.                 }
  856. #ifdef PARANOID
  857.                 if (level < -2048 || level > 2047)
  858.                     fprintf(stderr, "unquant error %d %dn", i, level);
  859. #endif
  860.                 block[i] = level;
  861.             }
  862.         }
  863.     } else {
  864.         i = 0;
  865.     unquant_even:
  866.         quant_matrix = default_non_intra_matrix;
  867.         for(;i<64;i++) {
  868.             level = block[i];
  869.             if (level) {
  870.                 if (level < 0) {
  871.                     level = -level;
  872.                     level = (((level << 1) + 1) * qscale *
  873.                              ((int) (quant_matrix[i]))) >> 4;
  874.                     level = (level - 1) | 1;
  875.                     level = -level;
  876.                 } else {
  877.                     level = (((level << 1) + 1) * qscale *
  878.                              ((int) (quant_matrix[i]))) >> 4;
  879.                     level = (level - 1) | 1;
  880.                 }
  881. #ifdef PARANOID
  882.                 if (level < -2048 || level > 2047)
  883.                     fprintf(stderr, "unquant error %d %dn", i, level);
  884. #endif
  885.                 block[i] = level;
  886.             }
  887.         }
  888.     }
  889. }
  890.                          
  892. static inline void encode_dc(MpegEncContext *s, int diff, int component)
  893. {
  894.     int adiff, index;
  896.     //    printf("dc=%d c=%dn", diff, component);
  897.     adiff = abs(diff);
  898.     index = vlc_dc_table[adiff];
  899.     if (component == 0) {
  900.         put_bits(&s->pb, vlc_dc_lum_bits[index], vlc_dc_lum_code[index]);
  901.     } else {
  902.         put_bits(&s->pb, vlc_dc_chroma_bits[index], vlc_dc_chroma_code[index]);
  903.     }
  904.     if (diff > 0) {
  905.         put_bits(&s->pb, index, (diff & ((1 << index) - 1)));
  906.     } else if (diff < 0) {
  907.         put_bits(&s->pb, index, ((diff - 1) & ((1 << index) - 1)));
  908.     }
  909. }
  911. static void encode_block(MpegEncContext *s, 
  912.                          DCTELEM *block, 
  913.                          int n)
  914. {
  915.     int alevel, level, last_non_zero, dc, diff, i, j, run, last_index;
  916.     int code, nbits, component;
  917.     
  918.     last_index = s->block_last_index[n];
  920.     /* DC coef */
  921.     if (s->mb_intra) {
  922.         component = (n <= 3 ? 0 : n - 4 + 1);
  923.         dc = block[0]; /* overflow is impossible */
  924.         diff = dc - s->last_dc[component];
  925.         encode_dc(s, diff, component);
  926.         s->last_dc[component] = dc;
  927.         i = 1;
  928.     } else {
  929.         /* encode the first coefficient : needs to be done here because
  930.            it is handled slightly differently */
  931.         level = block[0];
  932.         if (abs(level) == 1) {
  933.                 code = ((UINT32)level >> 31); /* the sign bit */
  934.                 put_bits(&s->pb, 2, code | 0x02);
  935.                 i = 1;
  936.         } else {
  937.             i = 0;
  938.             last_non_zero = -1;
  939.             goto next_coef;
  940.         }
  941.     }
  943.     /* now quantify & encode AC coefs */
  944.     last_non_zero = i - 1;
  945.     for(;i<=last_index;i++) {
  946.         j = zigzag_direct[i];
  947.         level = block[j];
  948.     next_coef:
  949. #if 0
  950.         if (level != 0)
  951.             printf("level[%d]=%dn", i, level);
  952. #endif            
  953.         /* encode using VLC */
  954.         if (level != 0) {
  955.             run = i - last_non_zero - 1;
  956.             alevel = abs(level);
  957.             //            printf("run=%d level=%dn", run, level);
  958.             if ( (run < HUFF_MAXRUN) && (alevel < huff_maxlevel[run])) {
  959.                 /* encode using the Huffman tables */
  960.                 code = (huff_table[run])[alevel];
  961.                 nbits = (huff_bits[run])[alevel];
  962.                 code |= ((UINT32)level >> 31); /* the sign bit */
  964.                 put_bits(&s->pb, nbits, code);
  965.             } else {
  966.                 /* escape: only clip in this case */
  967.                 put_bits(&s->pb, 6, 0x1);
  968.                 put_bits(&s->pb, 6, run);
  969.                 if (alevel < 128) {
  970.                     put_bits(&s->pb, 8, level & 0xff);
  971.                 } else {
  972.                     if (level < 0) {
  973.                         put_bits(&s->pb, 16, 0x8001 + level + 255);
  974.                     } else {
  975.                         put_bits(&s->pb, 16, level & 0xffff);
  976.                     }
  977.                 }
  978.             }
  979.             last_non_zero = i;
  980.         }
  981.     }
  982.     /* end of block */
  983.     put_bits(&s->pb, 2, 0x2);
  984. }
  987. /* rate control */
  989. /* an I frame is I_FRAME_SIZE_RATIO bigger than a P frame */
  990. #define I_FRAME_SIZE_RATIO 3.0
  991. #define QSCALE_K           20
  993. static void rate_control_init(MpegEncContext *s)
  994. {
  995.     s->wanted_bits = 0;
  997.     if (s->intra_only) {
  998.         s->I_frame_bits = s->bit_rate / s->frame_rate;
  999.         s->P_frame_bits = s->I_frame_bits;
  1000.     } else {
  1001.         s->P_frame_bits = (int) ((float)(s->gop_size * s->bit_rate) / 
  1002.                     (float)(s->frame_rate * (I_FRAME_SIZE_RATIO + s->gop_size - 1)));
  1003.         s->I_frame_bits = (int)(s->P_frame_bits * I_FRAME_SIZE_RATIO);
  1004.     }
  1005.     
  1006. #if defined(DEBUG)
  1007.     printf("I_frame_size=%d P_frame_size=%dn",
  1008.            s->I_frame_bits, s->P_frame_bits);
  1009. #endif
  1010. }
  1013. /*
  1014.  * This heuristic is rather poor, but at least we do not have to
  1015.  * change the qscale at every macroblock.
  1016.  */
  1017. static int rate_estimate_qscale(MpegEncContext *s)
  1018. {
  1019.     long long total_bits = s->total_bits;
  1020.     float q;
  1021.     int qscale, diff, qmin;
  1023.     if (s->pict_type == I_TYPE) {
  1024.         s->wanted_bits += s->I_frame_bits;
  1025.     } else {
  1026.         s->wanted_bits += s->P_frame_bits;
  1027.     }
  1028.     diff = s->wanted_bits - total_bits;
  1029.     q = 31.0 - (float)diff / (QSCALE_K * s->mb_height * s->mb_width);
  1030.     /* adjust for I frame */
  1031.     if (s->pict_type == I_TYPE && !s->intra_only) {
  1032.         q /= I_FRAME_SIZE_RATIO;
  1033.     }
  1035.     /* using a too small Q scale leeds to problems in mpeg1 and h263
  1036.        because AC coefficients are clamped to 255 or 127 */
  1037.     qmin = 3;
  1038.     if (q < qmin)
  1039.         q = qmin;
  1040.     else if (q > 31)
  1041.         q = 31;
  1042.     qscale = (int)(q + 0.5);
  1043. #if defined(DEBUG)
  1044.     printf("%d: total=%Ld br=%0.1f diff=%d qest=%0.1fn", 
  1045.            s->picture_number, 
  1046.            total_bits, (float)s->frame_rate * total_bits / s->picture_number, 
  1047.            diff, q);
  1048. #endif
  1049.     return qscale;
  1050. }
  1052. AVEncoder mpeg1video_encoder = {
  1053.     "mpeg1video",
  1054.     CODEC_TYPE_VIDEO,
  1055.     CODEC_ID_MPEG1VIDEO,
  1056.     sizeof(MpegEncContext),
  1057.     MPV_encode_init,
  1058.     MPV_encode_picture,
  1059.     MPV_encode_end,
  1060. };
  1062. AVEncoder h263_encoder = {
  1063.     "h263",
  1064.     CODEC_TYPE_VIDEO,
  1065.     CODEC_ID_H263,
  1066.     sizeof(MpegEncContext),
  1067.     MPV_encode_init,
  1068.     MPV_encode_picture,
  1069.     MPV_encode_end,
  1070. };
  1072. AVEncoder rv10_encoder = {
  1073.     "rv10",
  1074.     CODEC_TYPE_VIDEO,
  1075.     CODEC_ID_RV10,
  1076.     sizeof(MpegEncContext),
  1077.     MPV_encode_init,
  1078.     MPV_encode_picture,
  1079.     MPV_encode_end,
  1080. };
  1082. AVEncoder mjpeg_encoder = {
  1083.     "mjpeg",
  1084.     CODEC_TYPE_VIDEO,
  1085.     CODEC_ID_MJPEG,
  1086.     sizeof(MpegEncContext),
  1087.     MPV_encode_init,
  1088.     MPV_encode_picture,
  1089.     MPV_encode_end,
  1090. };
  1092. AVEncoder divx_encoder = {
  1093.     "divx",
  1094.     CODEC_TYPE_VIDEO,
  1095.     CODEC_ID_DIVX,
  1096.     sizeof(MpegEncContext),
  1097.     MPV_encode_init,
  1098.     MPV_encode_picture,
  1099.     MPV_encode_end,
  1100. };