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.
477 Commits
32 Branches
522MB
Tree: 1cb0edb40b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1cb0edb40b'
${ noResults }
FFmpeg/libavcodec/mpegvideo.c

1674 lines
54KB
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.         s->last_non_b_pict_type= s->pict_type;

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

  435.             /* swap next and last */

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

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

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

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

  440.         }

  441.     }

  442. }

  443. 

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

  445. void MPV_frame_end(MpegEncContext *s)

  446. {

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

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

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

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

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

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

  453.       }else{

  454.         /* mpeg4? / opendivx / xvid */

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

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

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

  458.       }

  459.     }

  460.     emms_c();

  461. }

  462. 

  463. int MPV_encode_picture(AVCodecContext *avctx,

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

  465. {

  466.     MpegEncContext *s = avctx->priv_data;

  467.     AVPicture *pict = data;

  468.     int i, j;

  469. 

  470.     if (s->fixed_qscale) 

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

  472. 

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

  474. 

  475.     if (!s->intra_only) {

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

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

  478.             s->pict_type = I_TYPE;

  479.         else

  480.             s->pict_type = P_TYPE;

  481.     } else {

  482.         s->pict_type = I_TYPE;

  483.     }

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

  485.     

  486.     MPV_frame_start(s);

  487.     

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

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

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

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

  492.         int dest_wrap = s->linesize;

  493.         int w = s->width;

  494.         int h = s->height;

  495. 

  496.         if (i >= 1) {

  497.             dest_wrap >>= 1;

  498.             w >>= 1;

  499.             h >>= 1;

  500.         }

  501. 

  502.         if(dest_wrap==src_wrap){

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

  504.         } else {

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

  506.                 memcpy(dest, src, w);

  507.                 dest += dest_wrap;

  508.                 src += src_wrap;

  509.             }

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

  511. 	    }

  512.     }

  513. 

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

  515.     

  516.     MPV_frame_end(s);

  517.     s->picture_number++;

  518. 

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

  520.         mjpeg_picture_trailer(s);

  521. 

  522.     flush_put_bits(&s->pb);

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

  524. 

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

  526.     if (avctx->get_psnr) {

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

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

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

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

  531.     }

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

  533. }

  534. 

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

  536. {

  537.     if (a < amin)

  538.         return amin;

  539.     else if (a > amax)

  540.         return amax;

  541.     else

  542.         return a;

  543. }

  544. 

  545. static inline void gmc1_motion(MpegEncContext *s,

  546.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  547.                                int dest_offset,

  548.                                UINT8 **ref_picture, int src_offset,

  549.                                int h)

  550. {

  551.     UINT8 *ptr;

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

  553.     int motion_x, motion_y;

  554. 

  555.     if(s->real_sprite_warping_points>1) printf("more than 1 warp point isnt supported\n");

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

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

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

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

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

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

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

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

  564.         motion_x =0;

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

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

  567.         motion_y =0;

  568.     

  569.     linesize = s->linesize;

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

  571. 

  572.     dest_y+=dest_offset;

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

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

  575. 

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

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

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

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

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

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

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

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

  584.         motion_x =0;

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

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

  587.         motion_y =0;

  588. 

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

  590.     ptr = ref_picture[1] + offset;

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

  592.     ptr = ref_picture[2] + offset;

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

  594.     

  595.     return;

  596. }

  597. 

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

  599. static inline void mpeg_motion(MpegEncContext *s,

  600.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  601.                                int dest_offset,

  602.                                UINT8 **ref_picture, int src_offset,

  603.                                int field_based, op_pixels_func *pix_op,

  604.                                int motion_x, int motion_y, int h)

  605. {

  606.     UINT8 *ptr;

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

  608. if(s->quarter_sample)

  609. {

  610.     motion_x>>=1;

  611.     motion_y>>=1;

  612. }

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

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

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

  616.                 

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

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

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

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

  621.         dxy &= ~1;

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

  623.     if (src_y == height)

  624.         dxy &= ~2;

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

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

  627.     dest_y += dest_offset;

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

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

  630. 

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

  632.         dxy = 0;

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

  634.             dxy |= 1;

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

  636.             dxy |= 2;

  637.         mx = motion_x >> 2;

  638.         my = motion_y >> 2;

  639.     } else {

  640.         mx = motion_x / 2;

  641.         my = motion_y / 2;

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

  643.         mx >>= 1;

  644.         my >>= 1;

  645.     }

  646.     

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

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

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

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

  651.         dxy &= ~1;

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

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

  654.         dxy &= ~2;

  655. 

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

  657.     ptr = ref_picture[1] + offset;

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

  659.     ptr = ref_picture[2] + offset;

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

  661. }

  662. 

  663. static inline void qpel_motion(MpegEncContext *s,

  664.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  665.                                int dest_offset,

  666.                                UINT8 **ref_picture, int src_offset,

  667.                                int field_based, op_pixels_func *pix_op,

  668.                                qpel_mc_func *qpix_op,

  669.                                int motion_x, int motion_y, int h)

  670. {

  671.     UINT8 *ptr;

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

  673. 

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

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

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

  677. 

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

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

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

  681.         dxy &= ~3;

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

  683.     if (src_y == height)

  684.         dxy &= ~12;

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

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

  687.     dest_y += dest_offset;

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

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

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

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

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

  693.     

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

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

  696. 

  697.     dxy = 0;

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

  699.         dxy |= 1;

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

  701.         dxy |= 2;

  702.     mx = mx >> 2;

  703.     my = my >> 2;

  704.     

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

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

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

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

  709.         dxy &= ~1;

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

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

  712.         dxy &= ~2;

  713. 

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

  715.     ptr = ref_picture[1] + offset;

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

  717.     ptr = ref_picture[2] + offset;

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

  719. }

  720. 

  721. 

  722. static inline void MPV_motion(MpegEncContext *s, 

  723.                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  724.                               int dir, UINT8 **ref_picture, 

  725.                               op_pixels_func *pix_op, qpel_mc_func *qpix_op)

  726. {

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

  728.     int mb_x, mb_y, i;

  729.     UINT8 *ptr, *dest;

  730. 

  731.     mb_x = s->mb_x;

  732.     mb_y = s->mb_y;

  733. 

  734.     switch(s->mv_type) {

  735.     case MV_TYPE_16X16:

  736.         if(s->mcsel){

  737. #if 0

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

  739.                         ref_picture, 0,

  740.                         0, pix_op,

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

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

  743.                         16);

  744. #else

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

  746.                         ref_picture, 0,

  747.                         16);

  748. #endif

  749.         }else if(s->quarter_sample && dir==0){ //FIXME

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

  751.                         ref_picture, 0,

  752.                         0, pix_op, qpix_op,

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

  754.         }else{

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

  756.                         ref_picture, 0,

  757.                         0, pix_op,

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

  759.         }           

  760.         break;

  761.     case MV_TYPE_8X8:

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

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

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

  765. 

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

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

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

  769.                     

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

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

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

  773.                 dxy &= ~1;

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

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

  776.                 dxy &= ~2;

  777.                     

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

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

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

  781.         }

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

  783.            with a special rounding */

  784.         mx = 0;

  785.         my = 0;

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

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

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

  789.         }

  790.         if (mx >= 0)

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

  792.         else {

  793.             mx = -mx;

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

  795.         }

  796.         if (my >= 0)

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

  798.         else {

  799.             my = -my;

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

  801.         }

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

  803.         mx >>= 1;

  804.         my >>= 1;

  805. 

  806.         src_x = mb_x * 8 + mx;

  807.         src_y = mb_y * 8 + my;

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

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

  810.             dxy &= ~1;

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

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

  813.             dxy &= ~2;

  814.         

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

  816.         ptr = ref_picture[1] + offset;

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

  818.         ptr = ref_picture[2] + offset;

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

  820.         break;

  821.     case MV_TYPE_FIELD:

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

  823.             /* top field */

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

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

  826.                         1, pix_op,

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

  828.             /* bottom field */

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

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

  831.                         1, pix_op,

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

  833.         } else {

  834.             

  835. 

  836.         }

  837.         break;

  838.     }

  839. }

  840. 

  841. 

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

  843. static inline void put_dct(MpegEncContext *s, 

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

  845. {

  846.     if (!s->mpeg2)

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

  848.     ff_idct (block);

  849.     put_pixels_clamped(block, dest, line_size);

  850. }

  851. 

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

  853. static inline void add_dct(MpegEncContext *s, 

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

  855. {

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

  857.         if (!s->mpeg2)

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

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

  860.         ff_idct (block);

  861.         add_pixels_clamped(block, dest, line_size);

  862.     }

  863. }

  864. 

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

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

  867. 

  868.    Important variables used:

  869.    s->mb_intra : true if intra macroblock

  870.    s->mv_dir   : motion vector direction

  871.    s->mv_type  : motion vector type

  872.    s->mv       : motion vector

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

  874.  */

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

  876. {

  877.     int mb_x, mb_y;

  878.     int dct_linesize, dct_offset;

  879.     op_pixels_func *op_pix;

  880.     qpel_mc_func *op_qpix;

  881. 

  882.     mb_x = s->mb_x;

  883.     mb_y = s->mb_y;

  884. 

  885. #ifdef FF_POSTPROCESS

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

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

  888. #endif

  889. 

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

  891.     if (!s->mb_intra) {

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

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

  894.           {

  895.             int wrap, xy, v;

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

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

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

  899.             v = 1024;

  900.             

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

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

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

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

  905.             /* ac pred */

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

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

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

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

  910.             if (s->h263_msmpeg4) {

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

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

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

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

  915.             }

  916.             /* chroma */

  917.             wrap = s->mb_width + 2;

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

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

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

  921.             /* ac pred */

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

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

  924.           }

  925.         } else {

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

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

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

  929.         }

  930.     }

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

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

  933. 

  934.     /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */

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

  936.       if(s->pict_type!=B_TYPE){

  937.         int xy, wrap, motion_x, motion_y;

  938.         

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

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

  941.         if (s->mb_intra) {

  942.             motion_x = 0;

  943.             motion_y = 0;

  944.             goto motion_init;

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

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

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

  948.         motion_init:

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

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

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

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

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

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

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

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

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

  958.         }

  959.       }

  960.     }

  961.     

  962.     if (!s->intra_only) {

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

  964.         UINT8 *mbskip_ptr;

  965. 

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

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

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

  969.             if (s->mb_skiped) {

  970.                 s->mb_skiped = 0;

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

  972.                 if (*mbskip_ptr != 0) 

  973.                     goto the_end;

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

  975.             } else {

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

  977.             }

  978.         }

  979. 

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

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

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

  983. 

  984.         if (s->interlaced_dct) {

  985.             dct_linesize = s->linesize * 2;

  986.             dct_offset = s->linesize;

  987.         } else {

  988.             dct_linesize = s->linesize;

  989.             dct_offset = s->linesize * 8;

  990.         }

  991. 

  992.         if (!s->mb_intra) {

  993.             /* motion handling */

  994.             if (!s->no_rounding){

  995.                 op_pix = put_pixels_tab;

  996.                 op_qpix= qpel_mc_rnd_tab;

  997.             }else{

  998.                 op_pix = put_no_rnd_pixels_tab;

  999.                 op_qpix= qpel_mc_no_rnd_tab;

  1000.             }

  1001. 

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

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

  1004.                 if (!s->no_rounding) 

  1005.                     op_pix = avg_pixels_tab;

  1006.                 else

  1007.                     op_pix = avg_no_rnd_pixels_tab;

  1008.             }

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

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

  1011.             }

  1012. 

  1013.             /* add dct residue */

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

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

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

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

  1018. 

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

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

  1021.         } else {

  1022.             /* dct only in intra block */

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

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

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

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

  1027. 

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

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

  1030.         }

  1031.     }

  1032.  the_end:

  1033.     emms_c();

  1034. }

  1035. 

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

  1037. {

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

  1039.     UINT8 *ptr;

  1040.     int i, motion_x, motion_y;

  1041. 

  1042.     s->picture_number = picture_number;

  1043.     if (!s->fixed_qscale) 

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

  1045. 

  1046.     /* precompute matrix */

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

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

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

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

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

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

  1053.     } else {

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

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

  1056.     }

  1057. 

  1058.     switch(s->out_format) {

  1059.     case FMT_MJPEG:

  1060.         mjpeg_picture_header(s);

  1061.         break;

  1062.     case FMT_H263:

  1063.         if (s->h263_msmpeg4) 

  1064.             msmpeg4_encode_picture_header(s, picture_number);

  1065.         else if (s->h263_pred)

  1066.             mpeg4_encode_picture_header(s, picture_number);

  1067.         else if (s->h263_rv10) 

  1068.             rv10_encode_picture_header(s, picture_number);

  1069.         else

  1070.             h263_encode_picture_header(s, picture_number);

  1071.         break;

  1072.     case FMT_MPEG1:

  1073.         mpeg1_encode_picture_header(s, picture_number);

  1074.         break;

  1075.     }

  1076.         

  1077.     /* init last dc values */

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

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

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

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

  1082.     s->mb_incr = 1;

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

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

  1085.     s->mv_type = MV_TYPE_16X16;

  1086.     s->mv_dir = MV_DIR_FORWARD;

  1087. 

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

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

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

  1091.             s->gob_index = 1;

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

  1093.             s->gob_index = 2;

  1094.         else

  1095.             s->gob_index = 4;

  1096.     }

  1097.     

  1098.     /* Reset the average MB variance */

  1099.     s->avg_mb_var = 0;

  1100.     

  1101.     /* Estimate motion for every MB */

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

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

  1104.             s->mb_x = mb_x;

  1105.             s->mb_y = mb_y;

  1106. 

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

  1108.             motion_x = 0;

  1109.             motion_y = 0;

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

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

  1112.                                               &motion_x,

  1113.                                               &motion_y);

  1114.             } else {

  1115.                 s->mb_intra = 1;

  1116.             }

  1117.             /* Store MB type and MV */

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

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

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

  1121.         }

  1122.     }

  1123.     

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

  1125.     

  1126.     s->block_wrap[0]=

  1127.     s->block_wrap[1]=

  1128.     s->block_wrap[2]=

  1129.     s->block_wrap[3]= s->mb_width*2 + 2;

  1130.     s->block_wrap[4]=

  1131.     s->block_wrap[5]= s->mb_width + 2;

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

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

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

  1135.         if (s->rtp_mode) {

  1136.             if (!mb_y) {

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

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

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

  1140.                 last_gob = h263_encode_gob_header(s, mb_y);

  1141.                 if (last_gob) {

  1142.                     s->first_gob_line = 1;

  1143.                 }

  1144.             }

  1145.         }

  1146.         

  1147.         s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;

  1148.         s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);

  1149.         s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;

  1150.         s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);

  1151.         s->block_index[4]= s->block_wrap[4]*(mb_y + 1)                    + s->block_wrap[0]*(s->mb_height*2 + 2);

  1152.         s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);

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

  1154. 

  1155.             s->mb_x = mb_x;

  1156.             s->mb_y = mb_y;

  1157.             s->block_index[0]+=2;

  1158.             s->block_index[1]+=2;

  1159.             s->block_index[2]+=2;

  1160.             s->block_index[3]+=2;

  1161.             s->block_index[4]++;

  1162.             s->block_index[5]++;

  1163. #if 0

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

  1165.             motion_x = 0;

  1166.             motion_y = 0;

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

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

  1169.                                               &motion_x,

  1170.                                               &motion_y);

  1171.             } else {

  1172.                 s->mb_intra = 1;

  1173.             }

  1174. #endif

  1175. 

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

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

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

  1179.             

  1180.             /* get the pixels */

  1181.             wrap = s->linesize;

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

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

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

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

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

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

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

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

  1190. 

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

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

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

  1194. 

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

  1196.             if (!s->mb_intra) {

  1197.                 int dxy, offset, mx, my;

  1198. 

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

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

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

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

  1203. 

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

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

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

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

  1208. 

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

  1210.                     /* special rounding for h263 */

  1211.                     dxy = 0;

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

  1213.                         dxy |= 1;

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

  1215.                         dxy |= 2;

  1216.                     mx = motion_x >> 2;

  1217.                     my = motion_y >> 2;

  1218.                 } else {

  1219.                     mx = motion_x / 2;

  1220.                     my = motion_y / 2;

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

  1222.                     mx >>= 1;

  1223.                     my >>= 1;

  1224.                 }

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

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

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

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

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

  1230.             }

  1231.             emms_c();

  1232.             

  1233. #if 0

  1234.             {

  1235.                 float adap_parm;

  1236.                 

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

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

  1239.             

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

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

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

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

  1244.             }

  1245. #endif

  1246.             /* DCT & quantize */

  1247.             if (s->h263_msmpeg4) {

  1248.                 msmpeg4_dc_scale(s);

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

  1250.                 h263_dc_scale(s);

  1251.             } else {

  1252.                 /* default quantization values */

  1253.                 s->y_dc_scale = 8;

  1254.                 s->c_dc_scale = 8;

  1255.             }

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

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

  1258.             }

  1259. 

  1260.             /* huffman encode */

  1261.             switch(s->out_format) {

  1262.             case FMT_MPEG1:

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

  1264.                 break;

  1265.             case FMT_H263:

  1266.                 if (s->h263_msmpeg4)

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

  1268.                 else if(s->h263_pred)

  1269.                     mpeg4_encode_mb(s, s->block, motion_x, motion_y);

  1270.                 else

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

  1272.                 break;

  1273.             case FMT_MJPEG:

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

  1275.                 break;

  1276.             }

  1277. 

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

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

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

  1281. 

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

  1283.         }

  1284. 

  1285. 

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

  1287.         if (s->rtp_mode) {

  1288.             if (!mb_y)

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

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

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

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

  1293.             }

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

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

  1296.             s->first_gob_line = 0;

  1297.         }

  1298.     }

  1299.     

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

  1301.         msmpeg4_encode_ext_header(s);

  1302. 

  1303.     //if (s->gob_number)

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

  1305.     

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

  1307.     if (s->rtp_mode) {

  1308.         flush_put_bits(&s->pb);

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

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

  1311.         if (s->rtp_callback)

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

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

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

  1315.     }

  1316. 

  1317. }

  1318. 

  1319. static int dct_quantize_c(MpegEncContext *s, 

  1320.                         DCTELEM *block, int n,

  1321.                         int qscale)

  1322. {

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

  1324.     const int *qmat;

  1325.     int minLevel, maxLevel;

  1326. 

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

  1328. 	/* mpeg4 */

  1329.         minLevel= -2048;

  1330. 	maxLevel= 2047;

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

  1332. 	/* mpeg1 */

  1333.         minLevel= -255;

  1334. 	maxLevel= 255;

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

  1336. 	/* (m)jpeg */

  1337.         minLevel= -1023;

  1338. 	maxLevel= 1023;

  1339.     }else{

  1340. 	/* h263 / msmpeg4 */

  1341.         minLevel= -128;

  1342. 	maxLevel= 127;

  1343.     }

  1344. 

  1345.     av_fdct (block);

  1346. 

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

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

  1349.     block_permute(block);

  1350. 

  1351.     if (s->mb_intra) {

  1352.         if (n < 4)

  1353.             q = s->y_dc_scale;

  1354.         else

  1355.             q = s->c_dc_scale;

  1356.         q = q << 3;

  1357.         

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

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

  1360.         i = 1;

  1361.         last_non_zero = 0;

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

  1363.             qmat = s->q_non_intra_matrix;

  1364.         } else {

  1365.             qmat = s->q_intra_matrix;

  1366.         }

  1367.     } else {

  1368.         i = 0;

  1369.         last_non_zero = -1;

  1370.         qmat = s->q_non_intra_matrix;

  1371.     }

  1372. 

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

  1374.         j = zigzag_direct[i];

  1375.         level = block[j];

  1376.         level = level * qmat[j];

  1377. #ifdef PARANOID

  1378.         {

  1379.             static int count = 0;

  1380.             int level1, level2, qmat1;

  1381.             double val;

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

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

  1384.             } else {

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

  1386.             }

  1387.             if (av_fdct != jpeg_fdct_ifast)

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

  1389.             else

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

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

  1392.             level1 = (int)val;

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

  1394.             if (level1 != level2) {

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

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

  1397.                         val);

  1398.                 count++;

  1399.             }

  1400. 

  1401.         }

  1402. #endif

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

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

  1405.            (QMAT_SHIFT - 3)))

  1406.         */

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

  1408.             level) {

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

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

  1411.                mpeg1: -255..255

  1412.                mpeg2: -2048..2047

  1413.                h263:  -128..127

  1414.                mpeg4: -2048..2047

  1415.             */

  1416.             if (level > maxLevel)

  1417.                 level = maxLevel;

  1418.             else if (level < minLevel)

  1419.                 level = minLevel;

  1420. 

  1421.             block[j] = level;

  1422.             last_non_zero = i;

  1423.         } else {

  1424.             block[j] = 0;

  1425.         }

  1426.     }

  1427.     return last_non_zero;

  1428. }

  1429. 

  1430. static void dct_unquantize_mpeg1_c(MpegEncContext *s, 

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

  1432. {

  1433.     int i, level, nCoeffs;

  1434.     const UINT16 *quant_matrix;

  1435. 

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

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

  1438.     

  1439.     if (s->mb_intra) {

  1440.         if (n < 4) 

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

  1442.         else

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

  1444.         /* XXX: only mpeg1 */

  1445.         quant_matrix = s->intra_matrix;

  1446.         for(i=1;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 = (int)(level * qscale * quant_matrix[j]) >> 3;

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

  1454.                     level = -level;

  1455.                 } else {

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

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

  1458.                 }

  1459. #ifdef PARANOID

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

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

  1462. #endif

  1463.                 block[j] = level;

  1464.             }

  1465.         }

  1466.     } else {

  1467.         i = 0;

  1468.         quant_matrix = s->non_intra_matrix;

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

  1470.             int j= zigzag_direct[i];

  1471.             level = block[j];

  1472.             if (level) {

  1473.                 if (level < 0) {

  1474.                     level = -level;

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

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

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

  1478.                     level = -level;

  1479.                 } else {

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

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

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

  1483.                 }

  1484. #ifdef PARANOID

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

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

  1487. #endif

  1488.                 block[j] = level;

  1489.             }

  1490.         }

  1491.     }

  1492. }

  1493. 

  1494. static void dct_unquantize_h263_c(MpegEncContext *s, 

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

  1496. {

  1497.     int i, level, qmul, qadd;

  1498.     int nCoeffs;

  1499.     

  1500.     if (s->mb_intra) {

  1501.         if (!s->h263_aic) {

  1502.             if (n < 4) 

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

  1504.             else

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

  1506.         }

  1507.         i = 1;

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

  1509.     } else {

  1510.         i = 0;

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

  1512.     }

  1513. 

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

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

  1516.         qadd = 0;

  1517.     else

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

  1519. 

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

  1521.         level = block[i];

  1522.         if (level) {

  1523.             if (level < 0) {

  1524.                 level = level * qmul - qadd;

  1525.             } else {

  1526.                 level = level * qmul + qadd;

  1527.             }

  1528. #ifdef PARANOID

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

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

  1531. #endif

  1532.             block[i] = level;

  1533.         }

  1534.     }

  1535. }

  1536. 

  1537. /* rate control */

  1538. 

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

  1540. #define I_FRAME_SIZE_RATIO 3.0

  1541. #define QSCALE_K           20

  1542. 

  1543. static void rate_control_init(MpegEncContext *s)

  1544. {

  1545.     s->wanted_bits = 0;

  1546. 

  1547.     if (s->intra_only) {

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

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

  1550.     } else {

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

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

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

  1554.     }

  1555.     

  1556. #if defined(DEBUG)

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

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

  1559. #endif

  1560. }

  1561. 

  1562. 

  1563. /*

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

  1565.  * change the qscale at every macroblock.

  1566.  */

  1567. static int rate_estimate_qscale(MpegEncContext *s)

  1568. {

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

  1570.     float q;

  1571.     int qscale, qmin;

  1572. 

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

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

  1575.     } else {

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

  1577.     }

  1578.     diff = s->wanted_bits - total_bits;

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

  1580.     /* adjust for I frame */

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

  1582.         q /= I_FRAME_SIZE_RATIO;

  1583.     }

  1584. 

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

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

  1587.     qmin = 3;

  1588.     if (q < qmin)

  1589.         q = qmin;

  1590.     else if (q > 31)

  1591.         q = 31;

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

  1593. #if defined(DEBUG)

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

  1595.            s->picture_number, 

  1596.            (double)total_bits, 

  1597.            (double)s->wanted_bits,

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

  1599.            total_bits / s->picture_number, 

  1600.            (int)diff, q);

  1601. #endif

  1602.     return qscale;

  1603. }

  1604. 

  1605. AVCodec mpeg1video_encoder = {

  1606.     "mpeg1video",

  1607.     CODEC_TYPE_VIDEO,

  1608.     CODEC_ID_MPEG1VIDEO,

  1609.     sizeof(MpegEncContext),

  1610.     MPV_encode_init,

  1611.     MPV_encode_picture,

  1612.     MPV_encode_end,

  1613. };

  1614. 

  1615. AVCodec h263_encoder = {

  1616.     "h263",

  1617.     CODEC_TYPE_VIDEO,

  1618.     CODEC_ID_H263,

  1619.     sizeof(MpegEncContext),

  1620.     MPV_encode_init,

  1621.     MPV_encode_picture,

  1622.     MPV_encode_end,

  1623. };

  1624. 

  1625. AVCodec h263p_encoder = {

  1626.     "h263p",

  1627.     CODEC_TYPE_VIDEO,

  1628.     CODEC_ID_H263P,

  1629.     sizeof(MpegEncContext),

  1630.     MPV_encode_init,

  1631.     MPV_encode_picture,

  1632.     MPV_encode_end,

  1633. };

  1634. 

  1635. AVCodec rv10_encoder = {

  1636.     "rv10",

  1637.     CODEC_TYPE_VIDEO,

  1638.     CODEC_ID_RV10,

  1639.     sizeof(MpegEncContext),

  1640.     MPV_encode_init,

  1641.     MPV_encode_picture,

  1642.     MPV_encode_end,

  1643. };

  1644. 

  1645. AVCodec mjpeg_encoder = {

  1646.     "mjpeg",

  1647.     CODEC_TYPE_VIDEO,

  1648.     CODEC_ID_MJPEG,

  1649.     sizeof(MpegEncContext),

  1650.     MPV_encode_init,

  1651.     MPV_encode_picture,

  1652.     MPV_encode_end,

  1653. };

  1654. 

  1655. AVCodec mpeg4_encoder = {

  1656.     "mpeg4",

  1657.     CODEC_TYPE_VIDEO,

  1658.     CODEC_ID_MPEG4,

  1659.     sizeof(MpegEncContext),

  1660.     MPV_encode_init,

  1661.     MPV_encode_picture,

  1662.     MPV_encode_end,

  1663. };

  1664. 

  1665. AVCodec msmpeg4_encoder = {

  1666.     "msmpeg4",

  1667.     CODEC_TYPE_VIDEO,

  1668.     CODEC_ID_MSMPEG4,

  1669.     sizeof(MpegEncContext),

  1670.     MPV_encode_init,

  1671.     MPV_encode_picture,

  1672.     MPV_encode_end,

  1673. };