falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
467 Commits
32 Branches
2.4GB
Tree: a674139801
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a674139801'
${ noResults }
FFmpeg/libavcodec/mpegvideo.c

1651 lines
52KB
Raw Blame History 

  1. /*

  2.  * The simplest mpeg encoder (well, it was the simplest!)

  3.  * Copyright (c) 2000,2001 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 <math.h>

  22. #include <string.h>

  23. #include "avcodec.h"

  24. #include "dsputil.h"

  25. #include "mpegvideo.h"

  26. 

  27. #ifdef USE_FASTMEMCPY

  28. #include "fastmemcpy.h"

  29. #endif

  30. 

  31. static void encode_picture(MpegEncContext *s, int picture_number);

  32. static void rate_control_init(MpegEncContext *s);

  33. static int rate_estimate_qscale(MpegEncContext *s);

  34. static void dct_unquantize_mpeg1_c(MpegEncContext *s, 

  35.                                    DCTELEM *block, int n, int qscale);

  36. static void dct_unquantize_h263_c(MpegEncContext *s, 

  37.                                   DCTELEM *block, int n, int qscale);

  38. static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);

  39. static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale);

  40. 

  41. int (*dct_quantize)(MpegEncContext *s, DCTELEM *block, int n, int qscale)= dct_quantize_c;

  42. void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;

  43. 

  44. #define EDGE_WIDTH 16

  45. 

  46. /* enable all paranoid tests for rounding, overflows, etc... */

  47. //#define PARANOID

  48. 

  49. //#define DEBUG

  50. 

  51. /* for jpeg fast DCT */

  52. #define CONST_BITS 14

  53. 

  54. static const unsigned short aanscales[64] = {

  55.     /* precomputed values scaled up by 14 bits */

  56.     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,

  57.     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,

  58.     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,

  59.     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,

  60.     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,

  61.     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,

  62.     8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,

  63.     4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247

  64. };

  65. 

  66. static UINT8 h263_chroma_roundtab[16] = {

  67.     0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,

  68. };

  69. 

  70. /* default motion estimation */

  71. int motion_estimation_method = ME_LOG;

  72. 

  73. extern UINT8 zigzag_end[64];

  74. 

  75. static void convert_matrix(int *qmat, UINT16 *qmat16, const UINT16 *quant_matrix, int qscale)

  76. {

  77.     int i;

  78. 

  79.     if (av_fdct == jpeg_fdct_ifast) {

  80.         for(i=0;i<64;i++) {

  81.             /* 16 <= qscale * quant_matrix[i] <= 7905 */

  82.             /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */

  83.             /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */

  84.             /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */

  85.             

  86.             qmat[block_permute_op(i)] = (int)((UINT64_C(1) << (QMAT_SHIFT + 11)) / 

  87.                             (aanscales[i] * qscale * quant_matrix[block_permute_op(i)]));

  88.         }

  89.     } else {

  90.         for(i=0;i<64;i++) {

  91.             /* We can safely suppose that 16 <= quant_matrix[i] <= 255

  92.                So 16           <= qscale * quant_matrix[i]             <= 7905

  93.                so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905

  94.                so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67

  95.             */

  96.             qmat[i]   = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);

  97.             qmat16[i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[block_permute_op(i)]);

  98.         }

  99.     }

  100. }

  101. 

  102. /* init common structure for both encoder and decoder */

  103. int MPV_common_init(MpegEncContext *s)

  104. {

  105.     int c_size, i;

  106.     UINT8 *pict;

  107. 

  108.     if (s->out_format == FMT_H263) 

  109.         s->dct_unquantize = dct_unquantize_h263_c;

  110.     else

  111.         s->dct_unquantize = dct_unquantize_mpeg1_c;

  112.         

  113. #ifdef HAVE_MMX

  114.     MPV_common_init_mmx(s);

  115. #endif

  116.     s->mb_width = (s->width + 15) / 16;

  117.     s->mb_height = (s->height + 15) / 16;

  118.     s->mb_num = s->mb_width * s->mb_height;

  119.     s->linesize = s->mb_width * 16 + 2 * EDGE_WIDTH;

  120. 

  121.     for(i=0;i<3;i++) {

  122.         int w, h, shift, pict_start;

  123. 

  124.         w = s->linesize;

  125.         h = s->mb_height * 16 + 2 * EDGE_WIDTH;

  126.         shift = (i == 0) ? 0 : 1;

  127.         c_size = (w >> shift) * (h >> shift);

  128.         pict_start = (w >> shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);

  129. 

  130.         pict = av_mallocz(c_size);

  131.         if (pict == NULL)

  132.             goto fail;

  133.         s->last_picture_base[i] = pict;

  134.         s->last_picture[i] = pict + pict_start;

  135.     

  136.         pict = av_mallocz(c_size);

  137.         if (pict == NULL)

  138.             goto fail;

  139.         s->next_picture_base[i] = pict;

  140.         s->next_picture[i] = pict + pict_start;

  141. 

  142.         if (s->has_b_frames) {

  143.             pict = av_mallocz(c_size);

  144.             if (pict == NULL) 

  145.                 goto fail;

  146.             s->aux_picture_base[i] = pict;

  147.             s->aux_picture[i] = pict + pict_start;

  148.         }

  149.     }

  150.     

  151.     if (s->encoding) {

  152.         /* Allocate MB type table */

  153.         s->mb_type = av_mallocz(s->mb_num * sizeof(char));

  154.         if (s->mb_type == NULL) {

  155.             perror("malloc");

  156.             goto fail;

  157.         }

  158.         

  159.         s->mb_var = av_mallocz(s->mb_num * sizeof(INT16));

  160.         if (s->mb_var == NULL) {

  161.             perror("malloc");

  162.             goto fail;

  163.         }

  164.         /* Allocate MV table */

  165.         /* By now we just have one MV per MB */

  166.         s->mv_table[0] = av_mallocz(s->mb_num * sizeof(INT16));

  167.         s->mv_table[1] = av_mallocz(s->mb_num * sizeof(INT16));

  168.         if (s->mv_table[1] == NULL || s->mv_table[0] == NULL) {

  169.             perror("malloc");

  170.             goto fail;

  171.         }

  172.     }

  173.     

  174.     if (s->out_format == FMT_H263) {

  175.         int size;

  176.         /* MV prediction */

  177.         size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);

  178.         s->motion_val = malloc(size * 2 * sizeof(INT16));

  179.         if (s->motion_val == NULL)

  180.             goto fail;

  181.         memset(s->motion_val, 0, size * 2 * sizeof(INT16));

  182.     }

  183. 

  184.     if (s->h263_pred || s->h263_plus) {

  185.         int y_size, c_size, i, size;

  186.         

  187.         /* dc values */

  188. 

  189.         y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);

  190.         c_size = (s->mb_width + 2) * (s->mb_height + 2);

  191.         size = y_size + 2 * c_size;

  192.         s->dc_val[0] = malloc(size * sizeof(INT16));

  193.         if (s->dc_val[0] == NULL)

  194.             goto fail;

  195.         s->dc_val[1] = s->dc_val[0] + y_size;

  196.         s->dc_val[2] = s->dc_val[1] + c_size;

  197.         for(i=0;i<size;i++)

  198.             s->dc_val[0][i] = 1024;

  199. 

  200.         /* ac values */

  201.         s->ac_val[0] = av_mallocz(size * sizeof(INT16) * 16);

  202.         if (s->ac_val[0] == NULL)

  203.             goto fail;

  204.         s->ac_val[1] = s->ac_val[0] + y_size;

  205.         s->ac_val[2] = s->ac_val[1] + c_size;

  206.         

  207.         /* cbp values */

  208.         s->coded_block = av_mallocz(y_size);

  209.         if (!s->coded_block)

  210.             goto fail;

  211. 

  212.         /* which mb is a intra block */

  213.         s->mbintra_table = av_mallocz(s->mb_num);

  214.         if (!s->mbintra_table)

  215.             goto fail;

  216.         memset(s->mbintra_table, 1, s->mb_num);

  217.     }

  218.     /* default structure is frame */

  219.     s->picture_structure = PICT_FRAME;

  220. 

  221.     /* init macroblock skip table */

  222.     if (!s->encoding) {

  223.         s->mbskip_table = av_mallocz(s->mb_num);

  224.         if (!s->mbskip_table)

  225.             goto fail;

  226.     }

  227. 

  228.     s->context_initialized = 1;

  229.     return 0;

  230.  fail:

  231.     MPV_common_end(s);

  232.     return -1;

  233. }

  234. 

  235. /* init common structure for both encoder and decoder */

  236. void MPV_common_end(MpegEncContext *s)

  237. {

  238.     int i;

  239. 

  240.     if (s->mb_type)

  241.         free(s->mb_type);

  242.     if (s->mb_var)

  243.         free(s->mb_var);

  244.     if (s->mv_table[0])

  245.         free(s->mv_table[0]);

  246.     if (s->mv_table[1])

  247.         free(s->mv_table[1]);

  248.     if (s->motion_val)

  249.         free(s->motion_val);

  250.     if (s->dc_val[0])

  251.         free(s->dc_val[0]);

  252.     if (s->ac_val[0])

  253.         free(s->ac_val[0]);

  254.     if (s->coded_block)

  255.         free(s->coded_block);

  256.     if (s->mbintra_table)

  257.         free(s->mbintra_table);

  258. 

  259.     if (s->mbskip_table)

  260.         free(s->mbskip_table);

  261.     for(i=0;i<3;i++) {

  262.         if (s->last_picture_base[i])

  263. 	    free(s->last_picture_base[i]);

  264. 	if (s->next_picture_base[i])

  265. 	    free(s->next_picture_base[i]);

  266.         if (s->has_b_frames)

  267.             free(s->aux_picture_base[i]);

  268.     }

  269.     s->context_initialized = 0;

  270. }

  271. 

  272. /* init video encoder */

  273. int MPV_encode_init(AVCodecContext *avctx)

  274. {

  275.     MpegEncContext *s = avctx->priv_data;

  276.     int i;

  277. 

  278.     s->bit_rate = avctx->bit_rate;

  279.     s->frame_rate = avctx->frame_rate;

  280.     s->width = avctx->width;

  281.     s->height = avctx->height;

  282.     s->gop_size = avctx->gop_size;

  283.     s->rtp_mode = avctx->rtp_mode;

  284.     s->rtp_payload_size = avctx->rtp_payload_size;

  285.     if (avctx->rtp_callback)

  286.         s->rtp_callback = avctx->rtp_callback;

  287.     s->avctx = avctx;

  288.     

  289.     if (s->gop_size <= 1) {

  290.         s->intra_only = 1;

  291.         s->gop_size = 12;

  292.     } else {

  293.         s->intra_only = 0;

  294.     }

  295.     s->full_search = motion_estimation_method;

  296. 

  297.     s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);

  298.     

  299.     switch(avctx->codec->id) {

  300.     case CODEC_ID_MPEG1VIDEO:

  301.         s->out_format = FMT_MPEG1;

  302.         break;

  303.     case CODEC_ID_MJPEG:

  304.         s->out_format = FMT_MJPEG;

  305.         s->intra_only = 1; /* force intra only for jpeg */

  306.         s->mjpeg_write_tables = 1; /* write all tables */

  307.         s->mjpeg_vsample[0] = 2; /* set up default sampling factors */

  308.         s->mjpeg_vsample[1] = 1; /* the only currently supported values */

  309.         s->mjpeg_vsample[2] = 1; 

  310.         s->mjpeg_hsample[0] = 2; 

  311.         s->mjpeg_hsample[1] = 1; 

  312.         s->mjpeg_hsample[2] = 1; 

  313.         if (mjpeg_init(s) < 0)

  314.             return -1;

  315.         break;

  316.     case CODEC_ID_H263:

  317.         if (h263_get_picture_format(s->width, s->height) == 7) {

  318.             printf("Input picture size isn't suitable for h263 codec! try h263+\n");

  319.             return -1;

  320.         }

  321.         s->out_format = FMT_H263;

  322.         break;

  323.     case CODEC_ID_H263P:

  324.         s->out_format = FMT_H263;

  325.         s->rtp_mode = 1;

  326.         s->rtp_payload_size = 1200; 

  327.         s->h263_plus = 1;

  328.         s->unrestricted_mv = 1;

  329.         

  330.         /* These are just to be sure */

  331.         s->umvplus = 0;

  332.         s->umvplus_dec = 0;

  333.         break;

  334.     case CODEC_ID_RV10:

  335.         s->out_format = FMT_H263;

  336.         s->h263_rv10 = 1;

  337.         break;

  338.     case CODEC_ID_MPEG4:

  339.         s->out_format = FMT_H263;

  340.         s->h263_pred = 1;

  341.         s->unrestricted_mv = 1;

  342.         break;

  343.     case CODEC_ID_MSMPEG4:

  344.         s->out_format = FMT_H263;

  345.         s->h263_msmpeg4 = 1;

  346.         s->h263_pred = 1;

  347.         s->unrestricted_mv = 1;

  348.         break;

  349.     default:

  350.         return -1;

  351.     }

  352. 

  353.     if (s->out_format == FMT_H263)

  354.         h263_encode_init_vlc(s);

  355. 

  356.     s->encoding = 1;

  357. 

  358.     /* init */

  359.     if (MPV_common_init(s) < 0)

  360.         return -1;

  361.     

  362.     /* init default q matrix */

  363.     for(i=0;i<64;i++) {

  364.         s->intra_matrix[i] = default_intra_matrix[i];

  365.         s->non_intra_matrix[i] = default_non_intra_matrix[i];

  366.     }

  367. 

  368.     /* rate control init */

  369.     rate_control_init(s);

  370. 

  371.     s->picture_number = 0;

  372.     s->fake_picture_number = 0;

  373.     /* motion detector init */

  374.     s->f_code = 1;

  375. 

  376.     return 0;

  377. }

  378. 

  379. int MPV_encode_end(AVCodecContext *avctx)

  380. {

  381.     MpegEncContext *s = avctx->priv_data;

  382. 

  383. #ifdef STATS

  384.     print_stats();

  385. #endif

  386.     MPV_common_end(s);

  387.     if (s->out_format == FMT_MJPEG)

  388.         mjpeg_close(s);

  389.       

  390.     return 0;

  391. }

  392. 

  393. /* draw the edges of width 'w' of an image of size width, height */

  394. static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)

  395. {

  396.     UINT8 *ptr, *last_line;

  397.     int i;

  398. 

  399.     last_line = buf + (height - 1) * wrap;

  400.     for(i=0;i<w;i++) {

  401.         /* top and bottom */

  402.         memcpy(buf - (i + 1) * wrap, buf, width);

  403.         memcpy(last_line + (i + 1) * wrap, last_line, width);

  404.     }

  405.     /* left and right */

  406.     ptr = buf;

  407.     for(i=0;i<height;i++) {

  408.         memset(ptr - w, ptr[0], w);

  409.         memset(ptr + width, ptr[width-1], w);

  410.         ptr += wrap;

  411.     }

  412.     /* corners */

  413.     for(i=0;i<w;i++) {

  414.         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */

  415.         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */

  416.         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */

  417.         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */

  418.     }

  419. }

  420. 

  421. /* generic function for encode/decode called before a frame is coded/decoded */

  422. void MPV_frame_start(MpegEncContext *s)

  423. {

  424.     int i;

  425.     UINT8 *tmp;

  426. 

  427.     s->mb_skiped = 0;

  428.     if (s->pict_type == B_TYPE) {

  429.         for(i=0;i<3;i++) {

  430.             s->current_picture[i] = s->aux_picture[i];

  431.         }

  432.     } else {

  433.         for(i=0;i<3;i++) {

  434.             /* swap next and last */

  435.             tmp = s->last_picture[i];

  436.             s->last_picture[i] = s->next_picture[i];

  437.             s->next_picture[i] = tmp;

  438.             s->current_picture[i] = tmp;

  439.         }

  440.     }

  441. }

  442. 

  443. /* generic function for encode/decode called after a frame has been coded/decoded */

  444. void MPV_frame_end(MpegEncContext *s)

  445. {

  446.     /* draw edge for correct motion prediction if outside */

  447.     if (s->pict_type != B_TYPE && !s->intra_only) {

  448.       if(s->avctx==NULL || s->avctx->codec->id!=CODEC_ID_MPEG4 || s->divx_version==500){

  449.         draw_edges(s->current_picture[0], s->linesize, s->mb_width*16, s->mb_height*16, EDGE_WIDTH);

  450.         draw_edges(s->current_picture[1], s->linesize/2, s->mb_width*8, s->mb_height*8, EDGE_WIDTH/2);

  451.         draw_edges(s->current_picture[2], s->linesize/2, s->mb_width*8, s->mb_height*8, EDGE_WIDTH/2);

  452.       }else{

  453.         /* mpeg4? / opendivx / xvid */

  454.         draw_edges(s->current_picture[0], s->linesize, s->width, s->height, EDGE_WIDTH);

  455.         draw_edges(s->current_picture[1], s->linesize/2, s->width/2, s->height/2, EDGE_WIDTH/2);

  456.         draw_edges(s->current_picture[2], s->linesize/2, s->width/2, s->height/2, EDGE_WIDTH/2);

  457.       }

  458.     }

  459.     emms_c();

  460. }

  461. 

  462. int MPV_encode_picture(AVCodecContext *avctx,

  463.                        unsigned char *buf, int buf_size, void *data)

  464. {

  465.     MpegEncContext *s = avctx->priv_data;

  466.     AVPicture *pict = data;

  467.     int i, j;

  468. 

  469.     if (s->fixed_qscale) 

  470.         s->qscale = avctx->quality;

  471. 

  472.     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);

  473. 

  474.     if (!s->intra_only) {

  475.         /* first picture of GOP is intra */

  476.         if ((s->picture_number % s->gop_size) == 0)

  477.             s->pict_type = I_TYPE;

  478.         else

  479.             s->pict_type = P_TYPE;

  480.     } else {

  481.         s->pict_type = I_TYPE;

  482.     }

  483.     avctx->key_frame = (s->pict_type == I_TYPE);

  484.     

  485.     MPV_frame_start(s);

  486.     

  487.     for(i=0;i<3;i++) {

  488.         UINT8 *src = pict->data[i];

  489.         UINT8 *dest = s->current_picture[i];

  490.         int src_wrap = pict->linesize[i];

  491.         int dest_wrap = s->linesize;

  492.         int w = s->width;

  493.         int h = s->height;

  494. 

  495.         if (i >= 1) {

  496.             dest_wrap >>= 1;

  497.             w >>= 1;

  498.             h >>= 1;

  499.         }

  500. 

  501.         if(dest_wrap==src_wrap){

  502.             s->new_picture[i] = pict->data[i];

  503.         } else {

  504.             for(j=0;j<h;j++) {

  505.                 memcpy(dest, src, w);

  506.                 dest += dest_wrap;

  507.                 src += src_wrap;

  508.             }

  509.             s->new_picture[i] = s->current_picture[i];

  510. 	    }

  511.     }

  512. 

  513.     encode_picture(s, s->picture_number);

  514.     

  515.     MPV_frame_end(s);

  516.     s->picture_number++;

  517. 

  518.     if (s->out_format == FMT_MJPEG)

  519.         mjpeg_picture_trailer(s);

  520. 

  521.     flush_put_bits(&s->pb);

  522.     s->total_bits += (pbBufPtr(&s->pb) - s->pb.buf) * 8;

  523. 

  524.     avctx->quality = s->qscale;

  525.     if (avctx->get_psnr) {

  526.         /* At this point pict->data should have the original frame   */

  527.         /* an s->current_picture should have the coded/decoded frame */

  528.         get_psnr(pict->data, s->current_picture,

  529.                  pict->linesize, s->linesize, avctx);

  530.     }

  531.     return pbBufPtr(&s->pb) - s->pb.buf;

  532. }

  533. 

  534. static inline int clip(int a, int amin, int amax)

  535. {

  536.     if (a < amin)

  537.         return amin;

  538.     else if (a > amax)

  539.         return amax;

  540.     else

  541.         return a;

  542. }

  543. 

  544. static inline void gmc1_motion(MpegEncContext *s,

  545.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  546.                                int dest_offset,

  547.                                UINT8 **ref_picture, int src_offset,

  548.                                int h)

  549. {

  550.     UINT8 *ptr;

  551.     int dxy, offset, mx, my, src_x, src_y, height, linesize;

  552.     int motion_x, motion_y;

  553. 

  554.     if(s->real_sprite_warping_points>1) printf("Oops, thats bad, contact the developers\n");

  555.     motion_x= s->sprite_offset[0][0];

  556.     motion_y= s->sprite_offset[0][1];

  557.     src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));

  558.     src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));

  559.     motion_x<<=(3-s->sprite_warping_accuracy);

  560.     motion_y<<=(3-s->sprite_warping_accuracy);

  561.     src_x = clip(src_x, -16, s->width);

  562.     if (src_x == s->width)

  563.         motion_x =0;

  564.     src_y = clip(src_y, -16, s->height);

  565.     if (src_y == s->height)

  566.         motion_y =0;

  567.     

  568.     linesize = s->linesize;

  569.     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;

  570. 

  571.     dest_y+=dest_offset;

  572.     gmc1(dest_y  , ptr  , linesize, h, motion_x&15, motion_y&15, s->no_rounding);

  573.     gmc1(dest_y+8, ptr+8, linesize, h, motion_x&15, motion_y&15, s->no_rounding);

  574. 

  575.     motion_x= s->sprite_offset[1][0];

  576.     motion_y= s->sprite_offset[1][1];

  577.     src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));

  578.     src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));

  579.     motion_x<<=(3-s->sprite_warping_accuracy);

  580.     motion_y<<=(3-s->sprite_warping_accuracy);

  581.     src_x = clip(src_x, -8, s->width>>1);

  582.     if (src_x == s->width>>1)

  583.         motion_x =0;

  584.     src_y = clip(src_y, -8, s->height>>1);

  585.     if (src_y == s->height>>1)

  586.         motion_y =0;

  587. 

  588.     offset = (src_y * linesize>>1) + src_x + (src_offset>>1);

  589.     ptr = ref_picture[1] + offset;

  590.     gmc1(dest_cb + (dest_offset>>1), ptr, linesize>>1, h>>1, motion_x&15, motion_y&15, s->no_rounding);

  591.     ptr = ref_picture[2] + offset;

  592.     gmc1(dest_cr + (dest_offset>>1), ptr, linesize>>1, h>>1, motion_x&15, motion_y&15, s->no_rounding);

  593.     

  594.     return;

  595. }

  596. 

  597. /* apply one mpeg motion vector to the three components */

  598. static inline void mpeg_motion(MpegEncContext *s,

  599.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  600.                                int dest_offset,

  601.                                UINT8 **ref_picture, int src_offset,

  602.                                int field_based, op_pixels_func *pix_op,

  603.                                int motion_x, int motion_y, int h)

  604. {

  605.     UINT8 *ptr;

  606.     int dxy, offset, mx, my, src_x, src_y, height, linesize;

  607. if(s->quarter_sample)

  608. {

  609.     motion_x>>=1;

  610.     motion_y>>=1;

  611. }

  612.     dxy = ((motion_y & 1) << 1) | (motion_x & 1);

  613.     src_x = s->mb_x * 16 + (motion_x >> 1);

  614.     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);

  615.                 

  616.     /* WARNING: do no forget half pels */

  617.     height = s->height >> field_based;

  618.     src_x = clip(src_x, -16, s->width);

  619.     if (src_x == s->width)

  620.         dxy &= ~1;

  621.     src_y = clip(src_y, -16, height);

  622.     if (src_y == height)

  623.         dxy &= ~2;

  624.     linesize = s->linesize << field_based;

  625.     ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;

  626.     dest_y += dest_offset;

  627.     pix_op[dxy](dest_y, ptr, linesize, h);

  628.     pix_op[dxy](dest_y + 8, ptr + 8, linesize, h);

  629. 

  630.     if (s->out_format == FMT_H263) {

  631.         dxy = 0;

  632.         if ((motion_x & 3) != 0)

  633.             dxy |= 1;

  634.         if ((motion_y & 3) != 0)

  635.             dxy |= 2;

  636.         mx = motion_x >> 2;

  637.         my = motion_y >> 2;

  638.     } else {

  639.         mx = motion_x / 2;

  640.         my = motion_y / 2;

  641.         dxy = ((my & 1) << 1) | (mx & 1);

  642.         mx >>= 1;

  643.         my >>= 1;

  644.     }

  645.     

  646.     src_x = s->mb_x * 8 + mx;

  647.     src_y = s->mb_y * (8 >> field_based) + my;

  648.     src_x = clip(src_x, -8, s->width >> 1);

  649.     if (src_x == (s->width >> 1))

  650.         dxy &= ~1;

  651.     src_y = clip(src_y, -8, height >> 1);

  652.     if (src_y == (height >> 1))

  653.         dxy &= ~2;

  654. 

  655.     offset = (src_y * (linesize >> 1)) + src_x + (src_offset >> 1);

  656.     ptr = ref_picture[1] + offset;

  657.     pix_op[dxy](dest_cb + (dest_offset >> 1), ptr, linesize >> 1, h >> 1);

  658.     ptr = ref_picture[2] + offset;

  659.     pix_op[dxy](dest_cr + (dest_offset >> 1), ptr, linesize >> 1, h >> 1);

  660. }

  661. 

  662. static inline void qpel_motion(MpegEncContext *s,

  663.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  664.                                int dest_offset,

  665.                                UINT8 **ref_picture, int src_offset,

  666.                                int field_based, op_pixels_func *pix_op,

  667.                                qpel_mc_func *qpix_op,

  668.                                int motion_x, int motion_y, int h)

  669. {

  670.     UINT8 *ptr;

  671.     int dxy, offset, mx, my, src_x, src_y, height, linesize;

  672. 

  673.     dxy = ((motion_y & 3) << 2) | (motion_x & 3);

  674.     src_x = s->mb_x * 16 + (motion_x >> 2);

  675.     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);

  676. 

  677.     height = s->height >> field_based;

  678.     src_x = clip(src_x, -16, s->width);

  679.     if (src_x == s->width)

  680.         dxy &= ~3;

  681.     src_y = clip(src_y, -16, height);

  682.     if (src_y == height)

  683.         dxy &= ~12;

  684.     linesize = s->linesize << field_based;

  685.     ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;

  686.     dest_y += dest_offset;

  687. //printf("%d %d %d\n", src_x, src_y, dxy);

  688.     qpix_op[dxy](dest_y                 , ptr                 , linesize, linesize, motion_x&3, motion_y&3);

  689.     qpix_op[dxy](dest_y              + 8, ptr              + 8, linesize, linesize, motion_x&3, motion_y&3);

  690.     qpix_op[dxy](dest_y + linesize*8    , ptr + linesize*8    , linesize, linesize, motion_x&3, motion_y&3);

  691.     qpix_op[dxy](dest_y + linesize*8 + 8, ptr + linesize*8 + 8, linesize, linesize, motion_x&3, motion_y&3);

  692.     

  693.     mx= (motion_x>>1) | (motion_x&1);

  694.     my= (motion_y>>1) | (motion_y&1);

  695. 

  696.     dxy = 0;

  697.     if ((mx & 3) != 0)

  698.         dxy |= 1;

  699.     if ((my & 3) != 0)

  700.         dxy |= 2;

  701.     mx = mx >> 2;

  702.     my = my >> 2;

  703.     

  704.     src_x = s->mb_x * 8 + mx;

  705.     src_y = s->mb_y * (8 >> field_based) + my;

  706.     src_x = clip(src_x, -8, s->width >> 1);

  707.     if (src_x == (s->width >> 1))

  708.         dxy &= ~1;

  709.     src_y = clip(src_y, -8, height >> 1);

  710.     if (src_y == (height >> 1))

  711.         dxy &= ~2;

  712. 

  713.     offset = (src_y * (linesize >> 1)) + src_x + (src_offset >> 1);

  714.     ptr = ref_picture[1] + offset;

  715.     pix_op[dxy](dest_cb + (dest_offset >> 1), ptr, linesize >> 1, h >> 1);

  716.     ptr = ref_picture[2] + offset;

  717.     pix_op[dxy](dest_cr + (dest_offset >> 1), ptr, linesize >> 1, h >> 1);

  718. }

  719. 

  720. 

  721. static inline void MPV_motion(MpegEncContext *s, 

  722.                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  723.                               int dir, UINT8 **ref_picture, 

  724.                               op_pixels_func *pix_op, qpel_mc_func *qpix_op)

  725. {

  726.     int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;

  727.     int mb_x, mb_y, i;

  728.     UINT8 *ptr, *dest;

  729. 

  730.     mb_x = s->mb_x;

  731.     mb_y = s->mb_y;

  732. 

  733.     switch(s->mv_type) {

  734.     case MV_TYPE_16X16:

  735.         if(s->mcsel){

  736. #if 0

  737.             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,

  738.                         ref_picture, 0,

  739.                         0, pix_op,

  740.                         s->sprite_offset[0][0]>>3,

  741.                         s->sprite_offset[0][1]>>3,

  742.                         16);

  743. #else

  744.             gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,

  745.                         ref_picture, 0,

  746.                         16);

  747. #endif

  748.         }else if(s->quarter_sample){

  749.             qpel_motion(s, dest_y, dest_cb, dest_cr, 0,

  750.                         ref_picture, 0,

  751.                         0, pix_op, qpix_op,

  752.                         s->mv[dir][0][0], s->mv[dir][0][1], 16);

  753.         }else{

  754.             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,

  755.                         ref_picture, 0,

  756.                         0, pix_op,

  757.                         s->mv[dir][0][0], s->mv[dir][0][1], 16);

  758.         }           

  759.         break;

  760.     case MV_TYPE_8X8:

  761.         for(i=0;i<4;i++) {

  762.             motion_x = s->mv[dir][i][0];

  763.             motion_y = s->mv[dir][i][1];

  764. 

  765.             dxy = ((motion_y & 1) << 1) | (motion_x & 1);

  766.             src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;

  767.             src_y = mb_y * 16 + (motion_y >> 1) + ((i >> 1) & 1) * 8;

  768.                     

  769.             /* WARNING: do no forget half pels */

  770.             src_x = clip(src_x, -16, s->width);

  771.             if (src_x == s->width)

  772.                 dxy &= ~1;

  773.             src_y = clip(src_y, -16, s->height);

  774.             if (src_y == s->height)

  775.                 dxy &= ~2;

  776.                     

  777.             ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);

  778.             dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;

  779.             pix_op[dxy](dest, ptr, s->linesize, 8);

  780.         }

  781.         /* In case of 8X8, we construct a single chroma motion vector

  782.            with a special rounding */

  783.         mx = 0;

  784.         my = 0;

  785.         for(i=0;i<4;i++) {

  786.             mx += s->mv[dir][i][0];

  787.             my += s->mv[dir][i][1];

  788.         }

  789.         if (mx >= 0)

  790.             mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));

  791.         else {

  792.             mx = -mx;

  793.             mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));

  794.         }

  795.         if (my >= 0)

  796.             my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));

  797.         else {

  798.             my = -my;

  799.             my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));

  800.         }

  801.         dxy = ((my & 1) << 1) | (mx & 1);

  802.         mx >>= 1;

  803.         my >>= 1;

  804. 

  805.         src_x = mb_x * 8 + mx;

  806.         src_y = mb_y * 8 + my;

  807.         src_x = clip(src_x, -8, s->width/2);

  808.         if (src_x == s->width/2)

  809.             dxy &= ~1;

  810.         src_y = clip(src_y, -8, s->height/2);

  811.         if (src_y == s->height/2)

  812.             dxy &= ~2;

  813.         

  814.         offset = (src_y * (s->linesize >> 1)) + src_x;

  815.         ptr = ref_picture[1] + offset;

  816.         pix_op[dxy](dest_cb, ptr, s->linesize >> 1, 8);

  817.         ptr = ref_picture[2] + offset;

  818.         pix_op[dxy](dest_cr, ptr, s->linesize >> 1, 8);

  819.         break;

  820.     case MV_TYPE_FIELD:

  821.         if (s->picture_structure == PICT_FRAME) {

  822.             /* top field */

  823.             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,

  824.                         ref_picture, s->field_select[dir][0] ? s->linesize : 0,

  825.                         1, pix_op,

  826.                         s->mv[dir][0][0], s->mv[dir][0][1], 8);

  827.             /* bottom field */

  828.             mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,

  829.                         ref_picture, s->field_select[dir][1] ? s->linesize : 0,

  830.                         1, pix_op,

  831.                         s->mv[dir][1][0], s->mv[dir][1][1], 8);

  832.         } else {

  833.             

  834. 

  835.         }

  836.         break;

  837.     }

  838. }

  839. 

  840. 

  841. /* put block[] to dest[] */

  842. static inline void put_dct(MpegEncContext *s, 

  843.                            DCTELEM *block, int i, UINT8 *dest, int line_size)

  844. {

  845.     if (!s->mpeg2)

  846.         s->dct_unquantize(s, block, i, s->qscale);

  847.     ff_idct (block);

  848.     put_pixels_clamped(block, dest, line_size);

  849. }

  850. 

  851. /* add block[] to dest[] */

  852. static inline void add_dct(MpegEncContext *s, 

  853.                            DCTELEM *block, int i, UINT8 *dest, int line_size)

  854. {

  855.     if (s->block_last_index[i] >= 0) {

  856.         if (!s->mpeg2)

  857.             if(s->encoding || (!s->h263_msmpeg4))

  858.                 s->dct_unquantize(s, block, i, s->qscale);

  859.         ff_idct (block);

  860.         add_pixels_clamped(block, dest, line_size);

  861.     }

  862. }

  863. 

  864. /* generic function called after a macroblock has been parsed by the

  865.    decoder or after it has been encoded by the encoder.

  866. 

  867.    Important variables used:

  868.    s->mb_intra : true if intra macroblock

  869.    s->mv_dir   : motion vector direction

  870.    s->mv_type  : motion vector type

  871.    s->mv       : motion vector

  872.    s->interlaced_dct : true if interlaced dct used (mpeg2)

  873.  */

  874. void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])

  875. {

  876.     int mb_x, mb_y;

  877.     int dct_linesize, dct_offset;

  878.     op_pixels_func *op_pix;

  879.     qpel_mc_func *op_qpix;

  880. 

  881.     mb_x = s->mb_x;

  882.     mb_y = s->mb_y;

  883. 

  884. #ifdef FF_POSTPROCESS

  885.     quant_store[mb_y][mb_x]=s->qscale;

  886.     //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);

  887. #endif

  888. 

  889.     /* update DC predictors for P macroblocks */

  890.     if (!s->mb_intra) {

  891.         if (s->h263_pred || s->h263_aic) {

  892.           if(s->mbintra_table[mb_x + mb_y*s->mb_width])

  893.           {

  894.             int wrap, xy, v;

  895.             s->mbintra_table[mb_x + mb_y*s->mb_width]=0;

  896.             wrap = 2 * s->mb_width + 2;

  897.             xy = 2 * mb_x + 1 +  (2 * mb_y + 1) * wrap;

  898.             v = 1024;

  899.             

  900.             s->dc_val[0][xy] = v;

  901.             s->dc_val[0][xy + 1] = v;

  902.             s->dc_val[0][xy + wrap] = v;

  903.             s->dc_val[0][xy + 1 + wrap] = v;

  904.             /* ac pred */

  905.             memset(s->ac_val[0][xy], 0, 16 * sizeof(INT16));

  906.             memset(s->ac_val[0][xy + 1], 0, 16 * sizeof(INT16));

  907.             memset(s->ac_val[0][xy + wrap], 0, 16 * sizeof(INT16));

  908.             memset(s->ac_val[0][xy + 1 + wrap], 0, 16 * sizeof(INT16));

  909.             if (s->h263_msmpeg4) {

  910.                 s->coded_block[xy] = 0;

  911.                 s->coded_block[xy + 1] = 0;

  912.                 s->coded_block[xy + wrap] = 0;

  913.                 s->coded_block[xy + 1 + wrap] = 0;

  914.             }

  915.             /* chroma */

  916.             wrap = s->mb_width + 2;

  917.             xy = mb_x + 1 + (mb_y + 1) * wrap;

  918.             s->dc_val[1][xy] = v;

  919.             s->dc_val[2][xy] = v;

  920.             /* ac pred */

  921.             memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));

  922.             memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));

  923.           }

  924.         } else {

  925.             s->last_dc[0] = 128 << s->intra_dc_precision;

  926.             s->last_dc[1] = 128 << s->intra_dc_precision;

  927.             s->last_dc[2] = 128 << s->intra_dc_precision;

  928.         }

  929.     }

  930.     else if (s->h263_pred || s->h263_aic)

  931.         s->mbintra_table[mb_x + mb_y*s->mb_width]=1;

  932. 

  933.     /* update motion predictor */

  934.     if (s->out_format == FMT_H263) {

  935.         int xy, wrap, motion_x, motion_y;

  936.         

  937.         wrap = 2 * s->mb_width + 2;

  938.         xy = 2 * mb_x + 1 + (2 * mb_y + 1) * wrap;

  939.         if (s->mb_intra) {

  940.             motion_x = 0;

  941.             motion_y = 0;

  942.             goto motion_init;

  943.         } else if (s->mv_type == MV_TYPE_16X16) {

  944.             motion_x = s->mv[0][0][0];

  945.             motion_y = s->mv[0][0][1];

  946.         motion_init:

  947.             /* no update if 8X8 because it has been done during parsing */

  948.             s->motion_val[xy][0] = motion_x;

  949.             s->motion_val[xy][1] = motion_y;

  950.             s->motion_val[xy + 1][0] = motion_x;

  951.             s->motion_val[xy + 1][1] = motion_y;

  952.             s->motion_val[xy + wrap][0] = motion_x;

  953.             s->motion_val[xy + wrap][1] = motion_y;

  954.             s->motion_val[xy + 1 + wrap][0] = motion_x;

  955.             s->motion_val[xy + 1 + wrap][1] = motion_y;

  956.         }

  957.     }

  958.     

  959.     if (!s->intra_only) {

  960.         UINT8 *dest_y, *dest_cb, *dest_cr;

  961.         UINT8 *mbskip_ptr;

  962. 

  963.         /* avoid copy if macroblock skipped in last frame too */

  964.         if (!s->encoding && s->pict_type != B_TYPE) {

  965.             mbskip_ptr = &s->mbskip_table[s->mb_y * s->mb_width + s->mb_x];

  966.             if (s->mb_skiped) {

  967.                 s->mb_skiped = 0;

  968.                 /* if previous was skipped too, then nothing to do ! */

  969.                 if (*mbskip_ptr != 0) 

  970.                     goto the_end;

  971.                 *mbskip_ptr = 1; /* indicate that this time we skiped it */

  972.             } else {

  973.                 *mbskip_ptr = 0; /* not skipped */

  974.             }

  975.         }

  976. 

  977.         dest_y = s->current_picture[0] + (mb_y * 16 * s->linesize) + mb_x * 16;

  978.         dest_cb = s->current_picture[1] + (mb_y * 8 * (s->linesize >> 1)) + mb_x * 8;

  979.         dest_cr = s->current_picture[2] + (mb_y * 8 * (s->linesize >> 1)) + mb_x * 8;

  980. 

  981.         if (s->interlaced_dct) {

  982.             dct_linesize = s->linesize * 2;

  983.             dct_offset = s->linesize;

  984.         } else {

  985.             dct_linesize = s->linesize;

  986.             dct_offset = s->linesize * 8;

  987.         }

  988. 

  989.         if (!s->mb_intra) {

  990.             /* motion handling */

  991.             if (!s->no_rounding){

  992.                 op_pix = put_pixels_tab;

  993.                 op_qpix= qpel_mc_rnd_tab;

  994.             }else{

  995.                 op_pix = put_no_rnd_pixels_tab;

  996.                 op_qpix= qpel_mc_no_rnd_tab;

  997.             }

  998. 

  999.             if (s->mv_dir & MV_DIR_FORWARD) {

  1000.                 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);

  1001.                 if (!s->no_rounding) 

  1002.                     op_pix = avg_pixels_tab;

  1003.                 else

  1004.                     op_pix = avg_no_rnd_pixels_tab;

  1005.             }

  1006.             if (s->mv_dir & MV_DIR_BACKWARD) {

  1007.                 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);

  1008.             }

  1009. 

  1010.             /* add dct residue */

  1011.             add_dct(s, block[0], 0, dest_y, dct_linesize);

  1012.             add_dct(s, block[1], 1, dest_y + 8, dct_linesize);

  1013.             add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);

  1014.             add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);

  1015. 

  1016.             add_dct(s, block[4], 4, dest_cb, s->linesize >> 1);

  1017.             add_dct(s, block[5], 5, dest_cr, s->linesize >> 1);

  1018.         } else {

  1019.             /* dct only in intra block */

  1020.             put_dct(s, block[0], 0, dest_y, dct_linesize);

  1021.             put_dct(s, block[1], 1, dest_y + 8, dct_linesize);

  1022.             put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);

  1023.             put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);

  1024. 

  1025.             put_dct(s, block[4], 4, dest_cb, s->linesize >> 1);

  1026.             put_dct(s, block[5], 5, dest_cr, s->linesize >> 1);

  1027.         }

  1028.     }

  1029.  the_end:

  1030.     emms_c();

  1031. }

  1032. 

  1033. static void encode_picture(MpegEncContext *s, int picture_number)

  1034. {

  1035.     int mb_x, mb_y, wrap, last_gob, pdif = 0;

  1036.     UINT8 *ptr;

  1037.     int i, motion_x, motion_y;

  1038. 

  1039.     s->picture_number = picture_number;

  1040.     if (!s->fixed_qscale) 

  1041.         s->qscale = rate_estimate_qscale(s);

  1042. 

  1043.     /* precompute matrix */

  1044.     if (s->out_format == FMT_MJPEG) {

  1045.         /* for mjpeg, we do include qscale in the matrix */

  1046.         s->intra_matrix[0] = default_intra_matrix[0];

  1047.         for(i=1;i<64;i++)

  1048.             s->intra_matrix[i] = (default_intra_matrix[i] * s->qscale) >> 3;

  1049.         convert_matrix(s->q_intra_matrix, s->q_intra_matrix16, s->intra_matrix, 8);

  1050.     } else {

  1051.         convert_matrix(s->q_intra_matrix, s->q_intra_matrix16, s->intra_matrix, s->qscale);

  1052.         convert_matrix(s->q_non_intra_matrix, s->q_non_intra_matrix16, s->non_intra_matrix, s->qscale);

  1053.     }

  1054. 

  1055.     switch(s->out_format) {

  1056.     case FMT_MJPEG:

  1057.         mjpeg_picture_header(s);

  1058.         break;

  1059.     case FMT_H263:

  1060.         if (s->h263_msmpeg4) 

  1061.             msmpeg4_encode_picture_header(s, picture_number);

  1062.         else if (s->h263_pred)

  1063.             mpeg4_encode_picture_header(s, picture_number);

  1064.         else if (s->h263_rv10) 

  1065.             rv10_encode_picture_header(s, picture_number);

  1066.         else

  1067.             h263_encode_picture_header(s, picture_number);

  1068.         break;

  1069.     case FMT_MPEG1:

  1070.         mpeg1_encode_picture_header(s, picture_number);

  1071.         break;

  1072.     }

  1073.         

  1074.     /* init last dc values */

  1075.     /* note: quant matrix value (8) is implied here */

  1076.     s->last_dc[0] = 128;

  1077.     s->last_dc[1] = 128;

  1078.     s->last_dc[2] = 128;

  1079.     s->mb_incr = 1;

  1080.     s->last_mv[0][0][0] = 0;

  1081.     s->last_mv[0][0][1] = 0;

  1082.     s->mv_type = MV_TYPE_16X16;

  1083.     s->mv_dir = MV_DIR_FORWARD;

  1084. 

  1085.     /* Get the GOB height based on picture height */

  1086.     if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {

  1087.         if (s->height <= 400)

  1088.             s->gob_index = 1;

  1089.         else if (s->height <= 800)

  1090.             s->gob_index = 2;

  1091.         else

  1092.             s->gob_index = 4;

  1093.     }

  1094.     

  1095.     /* Reset the average MB variance */

  1096.     s->avg_mb_var = 0;

  1097.     

  1098.     /* Estimate motion for every MB */

  1099.     for(mb_y=0; mb_y < s->mb_height; mb_y++) {

  1100.         for(mb_x=0; mb_x < s->mb_width; mb_x++) {

  1101.             s->mb_x = mb_x;

  1102.             s->mb_y = mb_y;

  1103. 

  1104.             /* compute motion vector and macro block type (intra or non intra) */

  1105.             motion_x = 0;

  1106.             motion_y = 0;

  1107.             if (s->pict_type == P_TYPE) {

  1108.                 s->mb_intra = estimate_motion(s, mb_x, mb_y,

  1109.                                               &motion_x,

  1110.                                               &motion_y);

  1111.             } else {

  1112.                 s->mb_intra = 1;

  1113.             }

  1114.             /* Store MB type and MV */

  1115.             s->mb_type[mb_y * s->mb_width + mb_x] = s->mb_intra;

  1116.             s->mv_table[0][mb_y * s->mb_width + mb_x] = motion_x;

  1117.             s->mv_table[1][mb_y * s->mb_width + mb_x] = motion_y;

  1118.         }

  1119.     }

  1120.     

  1121.     s->avg_mb_var = s->avg_mb_var / s->mb_num;        

  1122.     

  1123.     for(mb_y=0; mb_y < s->mb_height; mb_y++) {

  1124.         /* Put GOB header based on RTP MTU */

  1125.         /* TODO: Put all this stuff in a separate generic function */

  1126.         if (s->rtp_mode) {

  1127.             if (!mb_y) {

  1128.                 s->ptr_lastgob = s->pb.buf;

  1129.                 s->ptr_last_mb_line = s->pb.buf;

  1130.             } else if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4 && !(mb_y % s->gob_index)) {

  1131.                 last_gob = h263_encode_gob_header(s, mb_y);

  1132.                 if (last_gob) {

  1133.                     s->first_gob_line = 1;

  1134.                 }

  1135.             }

  1136.         }

  1137.         

  1138.         for(mb_x=0; mb_x < s->mb_width; mb_x++) {

  1139. 

  1140.             s->mb_x = mb_x;

  1141.             s->mb_y = mb_y;

  1142. #if 0

  1143.             /* compute motion vector and macro block type (intra or non intra) */

  1144.             motion_x = 0;

  1145.             motion_y = 0;

  1146.             if (s->pict_type == P_TYPE) {

  1147.                 s->mb_intra = estimate_motion(s, mb_x, mb_y,

  1148.                                               &motion_x,

  1149.                                               &motion_y);

  1150.             } else {

  1151.                 s->mb_intra = 1;

  1152.             }

  1153. #endif

  1154. 

  1155.             s->mb_intra = s->mb_type[mb_y * s->mb_width + mb_x];

  1156.             motion_x = s->mv_table[0][mb_y * s->mb_width + mb_x];

  1157.             motion_y = s->mv_table[1][mb_y * s->mb_width + mb_x];

  1158.             

  1159.             /* get the pixels */

  1160.             wrap = s->linesize;

  1161.             ptr = s->new_picture[0] + (mb_y * 16 * wrap) + mb_x * 16;

  1162.             get_pixels(s->block[0], ptr, wrap);

  1163.             get_pixels(s->block[1], ptr + 8, wrap);

  1164.             get_pixels(s->block[2], ptr + 8 * wrap, wrap);

  1165.             get_pixels(s->block[3], ptr + 8 * wrap + 8, wrap);

  1166.             wrap = s->linesize >> 1;

  1167.             ptr = s->new_picture[1] + (mb_y * 8 * wrap) + mb_x * 8;

  1168.             get_pixels(s->block[4], ptr, wrap);

  1169. 

  1170.             wrap = s->linesize >> 1;

  1171.             ptr = s->new_picture[2] + (mb_y * 8 * wrap) + mb_x * 8;

  1172.             get_pixels(s->block[5], ptr, wrap);

  1173. 

  1174.             /* subtract previous frame if non intra */

  1175.             if (!s->mb_intra) {

  1176.                 int dxy, offset, mx, my;

  1177. 

  1178.                 dxy = ((motion_y & 1) << 1) | (motion_x & 1);

  1179.                 ptr = s->last_picture[0] + 

  1180.                     ((mb_y * 16 + (motion_y >> 1)) * s->linesize) + 

  1181.                     (mb_x * 16 + (motion_x >> 1));

  1182. 

  1183.                 sub_pixels_2(s->block[0], ptr, s->linesize, dxy);

  1184.                 sub_pixels_2(s->block[1], ptr + 8, s->linesize, dxy);

  1185.                 sub_pixels_2(s->block[2], ptr + s->linesize * 8, s->linesize, dxy);

  1186.                 sub_pixels_2(s->block[3], ptr + 8 + s->linesize * 8, s->linesize ,dxy);

  1187. 

  1188.                 if (s->out_format == FMT_H263) {

  1189.                     /* special rounding for h263 */

  1190.                     dxy = 0;

  1191.                     if ((motion_x & 3) != 0)

  1192.                         dxy |= 1;

  1193.                     if ((motion_y & 3) != 0)

  1194.                         dxy |= 2;

  1195.                     mx = motion_x >> 2;

  1196.                     my = motion_y >> 2;

  1197.                 } else {

  1198.                     mx = motion_x / 2;

  1199.                     my = motion_y / 2;

  1200.                     dxy = ((my & 1) << 1) | (mx & 1);

  1201.                     mx >>= 1;

  1202.                     my >>= 1;

  1203.                 }

  1204.                 offset = ((mb_y * 8 + my) * (s->linesize >> 1)) + (mb_x * 8 + mx);

  1205.                 ptr = s->last_picture[1] + offset;

  1206.                 sub_pixels_2(s->block[4], ptr, s->linesize >> 1, dxy);

  1207.                 ptr = s->last_picture[2] + offset;

  1208.                 sub_pixels_2(s->block[5], ptr, s->linesize >> 1, dxy);

  1209.             }

  1210.             emms_c();

  1211.             

  1212. #if 0

  1213.             {

  1214.                 float adap_parm;

  1215.                 

  1216.                 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /

  1217.                             ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);

  1218.             

  1219.                 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d", 

  1220.                         (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P', 

  1221.                         s->qscale, adap_parm, s->qscale*adap_parm,

  1222.                         s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);

  1223.             }

  1224. #endif

  1225.             /* DCT & quantize */

  1226.             if (s->h263_msmpeg4) {

  1227.                 msmpeg4_dc_scale(s);

  1228.             } else if (s->h263_pred) {

  1229.                 h263_dc_scale(s);

  1230.             } else {

  1231.                 /* default quantization values */

  1232.                 s->y_dc_scale = 8;

  1233.                 s->c_dc_scale = 8;

  1234.             }

  1235.             for(i=0;i<6;i++) {

  1236.                 s->block_last_index[i] = dct_quantize(s, s->block[i], i, s->qscale);

  1237.             }

  1238. 

  1239.             /* huffman encode */

  1240.             switch(s->out_format) {

  1241.             case FMT_MPEG1:

  1242.                 mpeg1_encode_mb(s, s->block, motion_x, motion_y);

  1243.                 break;

  1244.             case FMT_H263:

  1245.                 if (s->h263_msmpeg4)

  1246.                     msmpeg4_encode_mb(s, s->block, motion_x, motion_y);

  1247.                 else

  1248.                     h263_encode_mb(s, s->block, motion_x, motion_y);

  1249.                 break;

  1250.             case FMT_MJPEG:

  1251.                 mjpeg_encode_mb(s, s->block);

  1252.                 break;

  1253.             }

  1254. 

  1255.             /* decompress blocks so that we keep the state of the decoder */

  1256.             s->mv[0][0][0] = motion_x;

  1257.             s->mv[0][0][1] = motion_y;

  1258. 

  1259.             MPV_decode_mb(s, s->block);

  1260.         }

  1261. 

  1262. 

  1263.         /* Obtain average GOB size for RTP */

  1264.         if (s->rtp_mode) {

  1265.             if (!mb_y)

  1266.                 s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;

  1267.             else if (!(mb_y % s->gob_index)) {    

  1268.                 s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;

  1269.                 s->ptr_last_mb_line = pbBufPtr(&s->pb);

  1270.             }

  1271.             //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y, 

  1272.             //                    (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize);

  1273.             s->first_gob_line = 0;

  1274.         }

  1275.     }

  1276.     

  1277.     if (s->h263_msmpeg4 && s->pict_type == I_TYPE)

  1278.         msmpeg4_encode_ext_header(s);

  1279. 

  1280.     //if (s->gob_number)

  1281.     //    fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);

  1282.     

  1283.     /* Send the last GOB if RTP */    

  1284.     if (s->rtp_mode) {

  1285.         flush_put_bits(&s->pb);

  1286.         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;

  1287.         /* Call the RTP callback to send the last GOB */

  1288.         if (s->rtp_callback)

  1289.             s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);

  1290.         s->ptr_lastgob = pbBufPtr(&s->pb);

  1291.         //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);

  1292.     }

  1293. 

  1294. }

  1295. 

  1296. static int dct_quantize_c(MpegEncContext *s, 

  1297.                         DCTELEM *block, int n,

  1298.                         int qscale)

  1299. {

  1300.     int i, j, level, last_non_zero, q;

  1301.     const int *qmat;

  1302.     int minLevel, maxLevel;

  1303. 

  1304.     if(s->avctx!=NULL && s->avctx->codec->id==CODEC_ID_MPEG4){

  1305. 	/* mpeg4 */

  1306.         minLevel= -2048;

  1307. 	maxLevel= 2047;

  1308.     }else if(s->out_format==FMT_MPEG1){

  1309. 	/* mpeg1 */

  1310.         minLevel= -255;

  1311. 	maxLevel= 255;

  1312.     }else if(s->out_format==FMT_MJPEG){

  1313. 	/* (m)jpeg */

  1314.         minLevel= -1023;

  1315. 	maxLevel= 1023;

  1316.     }else{

  1317. 	/* h263 / msmpeg4 */

  1318.         minLevel= -128;

  1319. 	maxLevel= 127;

  1320.     }

  1321. 

  1322.     av_fdct (block);

  1323. 

  1324.     /* we need this permutation so that we correct the IDCT

  1325.        permutation. will be moved into DCT code */

  1326.     block_permute(block);

  1327. 

  1328.     if (s->mb_intra) {

  1329.         if (n < 4)

  1330.             q = s->y_dc_scale;

  1331.         else

  1332.             q = s->c_dc_scale;

  1333.         q = q << 3;

  1334.         

  1335.         /* note: block[0] is assumed to be positive */

  1336.         block[0] = (block[0] + (q >> 1)) / q;

  1337.         i = 1;

  1338.         last_non_zero = 0;

  1339.         if (s->out_format == FMT_H263) {

  1340.             qmat = s->q_non_intra_matrix;

  1341.         } else {

  1342.             qmat = s->q_intra_matrix;

  1343.         }

  1344.     } else {

  1345.         i = 0;

  1346.         last_non_zero = -1;

  1347.         qmat = s->q_non_intra_matrix;

  1348.     }

  1349. 

  1350.     for(;i<64;i++) {

  1351.         j = zigzag_direct[i];

  1352.         level = block[j];

  1353.         level = level * qmat[j];

  1354. #ifdef PARANOID

  1355.         {

  1356.             static int count = 0;

  1357.             int level1, level2, qmat1;

  1358.             double val;

  1359.             if (qmat == s->q_non_intra_matrix) {

  1360.                 qmat1 = default_non_intra_matrix[j] * s->qscale;

  1361.             } else {

  1362.                 qmat1 = default_intra_matrix[j] * s->qscale;

  1363.             }

  1364.             if (av_fdct != jpeg_fdct_ifast)

  1365.                 val = ((double)block[j] * 8.0) / (double)qmat1;

  1366.             else

  1367.                 val = ((double)block[j] * 8.0 * 2048.0) / 

  1368.                     ((double)qmat1 * aanscales[j]);

  1369.             level1 = (int)val;

  1370.             level2 = level / (1 << (QMAT_SHIFT - 3));

  1371.             if (level1 != level2) {

  1372.                 fprintf(stderr, "%d: quant error qlevel=%d wanted=%d level=%d qmat1=%d qmat=%d wantedf=%0.6f\n", 

  1373.                         count, level2, level1, block[j], qmat1, qmat[j],

  1374.                         val);

  1375.                 count++;

  1376.             }

  1377. 

  1378.         }

  1379. #endif

  1380.         /* XXX: slight error for the low range. Test should be equivalent to

  1381.            (level <= -(1 << (QMAT_SHIFT - 3)) || level >= (1 <<

  1382.            (QMAT_SHIFT - 3)))

  1383.         */

  1384.         if (((level << (31 - (QMAT_SHIFT - 3))) >> (31 - (QMAT_SHIFT - 3))) != 

  1385.             level) {

  1386.             level = level / (1 << (QMAT_SHIFT - 3));

  1387.             /* XXX: currently, this code is not optimal. the range should be:

  1388.                mpeg1: -255..255

  1389.                mpeg2: -2048..2047

  1390.                h263:  -128..127

  1391.                mpeg4: -2048..2047

  1392.             */

  1393.             if (level > maxLevel)

  1394.                 level = maxLevel;

  1395.             else if (level < minLevel)

  1396.                 level = minLevel;

  1397. 

  1398.             block[j] = level;

  1399.             last_non_zero = i;

  1400.         } else {

  1401.             block[j] = 0;

  1402.         }

  1403.     }

  1404.     return last_non_zero;

  1405. }

  1406. 

  1407. static void dct_unquantize_mpeg1_c(MpegEncContext *s, 

  1408.                                    DCTELEM *block, int n, int qscale)

  1409. {

  1410.     int i, level, nCoeffs;

  1411.     const UINT16 *quant_matrix;

  1412. 

  1413.     if(s->alternate_scan) nCoeffs= 64;

  1414.     else nCoeffs= s->block_last_index[n]+1;

  1415.     

  1416.     if (s->mb_intra) {

  1417.         if (n < 4) 

  1418.             block[0] = block[0] * s->y_dc_scale;

  1419.         else

  1420.             block[0] = block[0] * s->c_dc_scale;

  1421.         /* XXX: only mpeg1 */

  1422.         quant_matrix = s->intra_matrix;

  1423.         for(i=1;i<nCoeffs;i++) {

  1424.             int j= zigzag_direct[i];

  1425.             level = block[j];

  1426.             if (level) {

  1427.                 if (level < 0) {

  1428.                     level = -level;

  1429.                     level = (int)(level * qscale * quant_matrix[j]) >> 3;

  1430.                     level = (level - 1) | 1;

  1431.                     level = -level;

  1432.                 } else {

  1433.                     level = (int)(level * qscale * quant_matrix[j]) >> 3;

  1434.                     level = (level - 1) | 1;

  1435.                 }

  1436. #ifdef PARANOID

  1437.                 if (level < -2048 || level > 2047)

  1438.                     fprintf(stderr, "unquant error %d %d\n", i, level);

  1439. #endif

  1440.                 block[j] = level;

  1441.             }

  1442.         }

  1443.     } else {

  1444.         i = 0;

  1445.         quant_matrix = s->non_intra_matrix;

  1446.         for(;i<nCoeffs;i++) {

  1447.             int j= zigzag_direct[i];

  1448.             level = block[j];

  1449.             if (level) {

  1450.                 if (level < 0) {

  1451.                     level = -level;

  1452.                     level = (((level << 1) + 1) * qscale *

  1453.                              ((int) (quant_matrix[j]))) >> 4;

  1454.                     level = (level - 1) | 1;

  1455.                     level = -level;

  1456.                 } else {

  1457.                     level = (((level << 1) + 1) * qscale *

  1458.                              ((int) (quant_matrix[j]))) >> 4;

  1459.                     level = (level - 1) | 1;

  1460.                 }

  1461. #ifdef PARANOID

  1462.                 if (level < -2048 || level > 2047)

  1463.                     fprintf(stderr, "unquant error %d %d\n", i, level);

  1464. #endif

  1465.                 block[j] = level;

  1466.             }

  1467.         }

  1468.     }

  1469. }

  1470. 

  1471. static void dct_unquantize_h263_c(MpegEncContext *s, 

  1472.                                   DCTELEM *block, int n, int qscale)

  1473. {

  1474.     int i, level, qmul, qadd;

  1475.     int nCoeffs;

  1476.     

  1477.     if (s->mb_intra) {

  1478.         if (!s->h263_aic) {

  1479.             if (n < 4) 

  1480.                 block[0] = block[0] * s->y_dc_scale;

  1481.             else

  1482.                 block[0] = block[0] * s->c_dc_scale;

  1483.         }

  1484.         i = 1;

  1485.         nCoeffs= 64; //does not allways use zigzag table 

  1486.     } else {

  1487.         i = 0;

  1488.         nCoeffs= zigzag_end[ s->block_last_index[n] ];

  1489.     }

  1490. 

  1491.     qmul = s->qscale << 1;

  1492.     if (s->h263_aic && s->mb_intra)

  1493.         qadd = 0;

  1494.     else

  1495.         qadd = (s->qscale - 1) | 1;

  1496. 

  1497.     for(;i<nCoeffs;i++) {

  1498.         level = block[i];

  1499.         if (level) {

  1500.             if (level < 0) {

  1501.                 level = level * qmul - qadd;

  1502.             } else {

  1503.                 level = level * qmul + qadd;

  1504.             }

  1505. #ifdef PARANOID

  1506.                 if (level < -2048 || level > 2047)

  1507.                     fprintf(stderr, "unquant error %d %d\n", i, level);

  1508. #endif

  1509.             block[i] = level;

  1510.         }

  1511.     }

  1512. }

  1513. 

  1514. /* rate control */

  1515. 

  1516. /* an I frame is I_FRAME_SIZE_RATIO bigger than a P frame */

  1517. #define I_FRAME_SIZE_RATIO 3.0

  1518. #define QSCALE_K           20

  1519. 

  1520. static void rate_control_init(MpegEncContext *s)

  1521. {

  1522.     s->wanted_bits = 0;

  1523. 

  1524.     if (s->intra_only) {

  1525.         s->I_frame_bits = ((INT64)s->bit_rate * FRAME_RATE_BASE) / s->frame_rate;

  1526.         s->P_frame_bits = s->I_frame_bits;

  1527.     } else {

  1528.         s->P_frame_bits = (int) ((float)(s->gop_size * s->bit_rate) / 

  1529.                                  (float)((float)s->frame_rate / FRAME_RATE_BASE * (I_FRAME_SIZE_RATIO + s->gop_size - 1)));

  1530.         s->I_frame_bits = (int)(s->P_frame_bits * I_FRAME_SIZE_RATIO);

  1531.     }

  1532.     

  1533. #if defined(DEBUG)

  1534.     printf("I_frame_size=%d P_frame_size=%d\n",

  1535.            s->I_frame_bits, s->P_frame_bits);

  1536. #endif

  1537. }

  1538. 

  1539. 

  1540. /*

  1541.  * This heuristic is rather poor, but at least we do not have to

  1542.  * change the qscale at every macroblock.

  1543.  */

  1544. static int rate_estimate_qscale(MpegEncContext *s)

  1545. {

  1546.     INT64 diff, total_bits = s->total_bits;

  1547.     float q;

  1548.     int qscale, qmin;

  1549. 

  1550.     if (s->pict_type == I_TYPE) {

  1551.         s->wanted_bits += s->I_frame_bits;

  1552.     } else {

  1553.         s->wanted_bits += s->P_frame_bits;

  1554.     }

  1555.     diff = s->wanted_bits - total_bits;

  1556.     q = 31.0 - (float)diff / (QSCALE_K * s->mb_height * s->mb_width);

  1557.     /* adjust for I frame */

  1558.     if (s->pict_type == I_TYPE && !s->intra_only) {

  1559.         q /= I_FRAME_SIZE_RATIO;

  1560.     }

  1561. 

  1562.     /* using a too small Q scale leeds to problems in mpeg1 and h263

  1563.        because AC coefficients are clamped to 255 or 127 */

  1564.     qmin = 3;

  1565.     if (q < qmin)

  1566.         q = qmin;

  1567.     else if (q > 31)

  1568.         q = 31;

  1569.     qscale = (int)(q + 0.5);

  1570. #if defined(DEBUG)

  1571.     printf("\n%d: total=%0.0f wanted=%0.0f br=%0.1f diff=%d qest=%2.1f\n", 

  1572.            s->picture_number, 

  1573.            (double)total_bits, 

  1574.            (double)s->wanted_bits,

  1575.            (float)s->frame_rate / FRAME_RATE_BASE * 

  1576.            total_bits / s->picture_number, 

  1577.            (int)diff, q);

  1578. #endif

  1579.     return qscale;

  1580. }

  1581. 

  1582. AVCodec mpeg1video_encoder = {

  1583.     "mpeg1video",

  1584.     CODEC_TYPE_VIDEO,

  1585.     CODEC_ID_MPEG1VIDEO,

  1586.     sizeof(MpegEncContext),

  1587.     MPV_encode_init,

  1588.     MPV_encode_picture,

  1589.     MPV_encode_end,

  1590. };

  1591. 

  1592. AVCodec h263_encoder = {

  1593.     "h263",

  1594.     CODEC_TYPE_VIDEO,

  1595.     CODEC_ID_H263,

  1596.     sizeof(MpegEncContext),

  1597.     MPV_encode_init,

  1598.     MPV_encode_picture,

  1599.     MPV_encode_end,

  1600. };

  1601. 

  1602. AVCodec h263p_encoder = {

  1603.     "h263p",

  1604.     CODEC_TYPE_VIDEO,

  1605.     CODEC_ID_H263P,

  1606.     sizeof(MpegEncContext),

  1607.     MPV_encode_init,

  1608.     MPV_encode_picture,

  1609.     MPV_encode_end,

  1610. };

  1611. 

  1612. AVCodec rv10_encoder = {

  1613.     "rv10",

  1614.     CODEC_TYPE_VIDEO,

  1615.     CODEC_ID_RV10,

  1616.     sizeof(MpegEncContext),

  1617.     MPV_encode_init,

  1618.     MPV_encode_picture,

  1619.     MPV_encode_end,

  1620. };

  1621. 

  1622. AVCodec mjpeg_encoder = {

  1623.     "mjpeg",

  1624.     CODEC_TYPE_VIDEO,

  1625.     CODEC_ID_MJPEG,

  1626.     sizeof(MpegEncContext),

  1627.     MPV_encode_init,

  1628.     MPV_encode_picture,

  1629.     MPV_encode_end,

  1630. };

  1631. 

  1632. AVCodec mpeg4_encoder = {

  1633.     "mpeg4",

  1634.     CODEC_TYPE_VIDEO,

  1635.     CODEC_ID_MPEG4,

  1636.     sizeof(MpegEncContext),

  1637.     MPV_encode_init,

  1638.     MPV_encode_picture,

  1639.     MPV_encode_end,

  1640. };

  1641. 

  1642. AVCodec msmpeg4_encoder = {

  1643.     "msmpeg4",

  1644.     CODEC_TYPE_VIDEO,

  1645.     CODEC_ID_MSMPEG4,

  1646.     sizeof(MpegEncContext),

  1647.     MPV_encode_init,

  1648.     MPV_encode_picture,

  1649.     MPV_encode_end,

  1650. };