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

1505 lines
47KB
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){

  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.         /* OpenDivx, but i dunno how to distinguish it from mpeg4 */

  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.     return pbBufPtr(&s->pb) - s->pb.buf;

  526. }

  527. 

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

  529. {

  530.     if (a < amin)

  531.         return amin;

  532.     else if (a > amax)

  533.         return amax;

  534.     else

  535.         return a;

  536. }

  537. 

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

  539. static inline void mpeg_motion(MpegEncContext *s,

  540.                                UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  541.                                int dest_offset,

  542.                                UINT8 **ref_picture, int src_offset,

  543.                                int field_based, op_pixels_func *pix_op,

  544.                                int motion_x, int motion_y, int h)

  545. {

  546.     UINT8 *ptr;

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

  548.     

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

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

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

  552.                 

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

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

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

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

  557.         dxy &= ~1;

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

  559.     if (src_y == height)

  560.         dxy &= ~2;

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

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

  563.     dest_y += dest_offset;

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

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

  566. 

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

  568.         dxy = 0;

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

  570.             dxy |= 1;

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

  572.             dxy |= 2;

  573.         mx = motion_x >> 2;

  574.         my = motion_y >> 2;

  575.     } else {

  576.         mx = motion_x / 2;

  577.         my = motion_y / 2;

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

  579.         mx >>= 1;

  580.         my >>= 1;

  581.     }

  582.     

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

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

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

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

  587.         dxy &= ~1;

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

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

  590.         dxy &= ~2;

  591. 

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

  593.     ptr = ref_picture[1] + offset;

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

  595.     ptr = ref_picture[2] + offset;

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

  597. }

  598. 

  599. static inline void MPV_motion(MpegEncContext *s, 

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

  601.                               int dir, UINT8 **ref_picture, 

  602.                               op_pixels_func *pix_op)

  603. {

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

  605.     int mb_x, mb_y, i;

  606.     UINT8 *ptr, *dest;

  607. 

  608.     mb_x = s->mb_x;

  609.     mb_y = s->mb_y;

  610. 

  611.     switch(s->mv_type) {

  612.     case MV_TYPE_16X16:

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

  614.                     ref_picture, 0,

  615.                     0, pix_op,

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

  617.         break;

  618.     case MV_TYPE_8X8:

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

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

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

  622. 

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

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

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

  626.                     

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

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

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

  630.                 dxy &= ~1;

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

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

  633.                 dxy &= ~2;

  634.                     

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

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

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

  638.         }

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

  640.            with a special rounding */

  641.         mx = 0;

  642.         my = 0;

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

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

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

  646.         }

  647.         if (mx >= 0)

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

  649.         else {

  650.             mx = -mx;

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

  652.         }

  653.         if (my >= 0)

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

  655.         else {

  656.             my = -my;

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

  658.         }

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

  660.         mx >>= 1;

  661.         my >>= 1;

  662. 

  663.         src_x = mb_x * 8 + mx;

  664.         src_y = mb_y * 8 + my;

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

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

  667.             dxy &= ~1;

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

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

  670.             dxy &= ~2;

  671.         

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

  673.         ptr = ref_picture[1] + offset;

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

  675.         ptr = ref_picture[2] + offset;

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

  677.         break;

  678.     case MV_TYPE_FIELD:

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

  680.             /* top field */

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

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

  683.                         1, pix_op,

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

  685.             /* bottom field */

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

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

  688.                         1, pix_op,

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

  690.         } else {

  691.             

  692. 

  693.         }

  694.         break;

  695.     }

  696. }

  697. 

  698. 

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

  700. static inline void put_dct(MpegEncContext *s, 

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

  702. {

  703.     if (!s->mpeg2)

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

  705.     ff_idct (block);

  706.     put_pixels_clamped(block, dest, line_size);

  707. }

  708. 

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

  710. static inline void add_dct(MpegEncContext *s, 

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

  712. {

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

  714.         if (!s->mpeg2)

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

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

  717.         ff_idct (block);

  718.         add_pixels_clamped(block, dest, line_size);

  719.     }

  720. }

  721. 

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

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

  724. 

  725.    Important variables used:

  726.    s->mb_intra : true if intra macroblock

  727.    s->mv_dir   : motion vector direction

  728.    s->mv_type  : motion vector type

  729.    s->mv       : motion vector

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

  731.  */

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

  733. {

  734.     int mb_x, mb_y;

  735.     int dct_linesize, dct_offset;

  736.     op_pixels_func *op_pix;

  737. 

  738.     mb_x = s->mb_x;

  739.     mb_y = s->mb_y;

  740. 

  741. #ifdef FF_POSTPROCESS

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

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

  744. #endif

  745. 

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

  747.     if (!s->mb_intra) {

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

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

  750.           {

  751.             int wrap, xy, v;

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

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

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

  755.             v = 1024;

  756.             

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

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

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

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

  761.             /* ac pred */

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

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

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

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

  766.             if (s->h263_msmpeg4) {

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

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

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

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

  771.             }

  772.             /* chroma */

  773.             wrap = s->mb_width + 2;

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

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

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

  777.             /* ac pred */

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

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

  780.           }

  781.         } else {

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

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

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

  785.         }

  786.     }

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

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

  789. 

  790.     /* update motion predictor */

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

  792.         int xy, wrap, motion_x, motion_y;

  793.         

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

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

  796.         if (s->mb_intra) {

  797.             motion_x = 0;

  798.             motion_y = 0;

  799.             goto motion_init;

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

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

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

  803.         motion_init:

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

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

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

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

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

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

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

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

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

  813.         }

  814.     }

  815.     

  816.     if (!s->intra_only) {

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

  818.         UINT8 *mbskip_ptr;

  819. 

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

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

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

  823.             if (s->mb_skiped) {

  824.                 s->mb_skiped = 0;

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

  826.                 if (*mbskip_ptr != 0) 

  827.                     goto the_end;

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

  829.             } else {

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

  831.             }

  832.         }

  833. 

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

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

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

  837. 

  838.         if (s->interlaced_dct) {

  839.             dct_linesize = s->linesize * 2;

  840.             dct_offset = s->linesize;

  841.         } else {

  842.             dct_linesize = s->linesize;

  843.             dct_offset = s->linesize * 8;

  844.         }

  845. 

  846.         if (!s->mb_intra) {

  847.             /* motion handling */

  848.             if (!s->no_rounding) 

  849.                 op_pix = put_pixels_tab;

  850.             else

  851.                 op_pix = put_no_rnd_pixels_tab;

  852. 

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

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

  855.                 if (!s->no_rounding) 

  856.                     op_pix = avg_pixels_tab;

  857.                 else

  858.                     op_pix = avg_no_rnd_pixels_tab;

  859.             }

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

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

  862.             }

  863. 

  864.             /* add dct residue */

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

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

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

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

  869. 

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

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

  872.         } else {

  873.             /* dct only in intra block */

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

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

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

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

  878. 

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

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

  881.         }

  882.     }

  883.  the_end:

  884.     emms_c();

  885. }

  886. 

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

  888. {

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

  890.     UINT8 *ptr;

  891.     int i, motion_x, motion_y;

  892. 

  893.     s->picture_number = picture_number;

  894.     if (!s->fixed_qscale) 

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

  896. 

  897.     /* precompute matrix */

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

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

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

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

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

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

  904.     } else {

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

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

  907.     }

  908. 

  909.     switch(s->out_format) {

  910.     case FMT_MJPEG:

  911.         mjpeg_picture_header(s);

  912.         break;

  913.     case FMT_H263:

  914.         if (s->h263_msmpeg4) 

  915.             msmpeg4_encode_picture_header(s, picture_number);

  916.         else if (s->h263_pred)

  917.             mpeg4_encode_picture_header(s, picture_number);

  918.         else if (s->h263_rv10) 

  919.             rv10_encode_picture_header(s, picture_number);

  920.         else

  921.             h263_encode_picture_header(s, picture_number);

  922.         break;

  923.     case FMT_MPEG1:

  924.         mpeg1_encode_picture_header(s, picture_number);

  925.         break;

  926.     }

  927.         

  928.     /* init last dc values */

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

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

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

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

  933.     s->mb_incr = 1;

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

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

  936.     s->mv_type = MV_TYPE_16X16;

  937.     s->mv_dir = MV_DIR_FORWARD;

  938. 

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

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

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

  942.             s->gob_index = 1;

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

  944.             s->gob_index = 2;

  945.         else

  946.             s->gob_index = 4;

  947.     }

  948.     

  949.     /* Reset the average MB variance */

  950.     s->avg_mb_var = 0;

  951.     

  952.     /* Estimate motion for every MB */

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

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

  955.             s->mb_x = mb_x;

  956.             s->mb_y = mb_y;

  957. 

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

  959.             motion_x = 0;

  960.             motion_y = 0;

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

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

  963.                                               &motion_x,

  964.                                               &motion_y);

  965.             } else {

  966.                 s->mb_intra = 1;

  967.             }

  968.             /* Store MB type and MV */

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

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

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

  972.         }

  973.     }

  974.     

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

  976.     

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

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

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

  980.         if (s->rtp_mode) {

  981.             if (!mb_y) {

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

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

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

  985.                 last_gob = h263_encode_gob_header(s, mb_y);

  986.                 if (last_gob) {

  987.                     s->first_gob_line = 1;

  988.                 }

  989.             }

  990.         }

  991.         

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

  993. 

  994.             s->mb_x = mb_x;

  995.             s->mb_y = mb_y;

  996. #if 0

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

  998.             motion_x = 0;

  999.             motion_y = 0;

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

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

  1002.                                               &motion_x,

  1003.                                               &motion_y);

  1004.             } else {

  1005.                 s->mb_intra = 1;

  1006.             }

  1007. #endif

  1008. 

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

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

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

  1012.             

  1013.             /* get the pixels */

  1014.             wrap = s->linesize;

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

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

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

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

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

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

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

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

  1023. 

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

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

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

  1027. 

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

  1029.             if (!s->mb_intra) {

  1030.                 int dxy, offset, mx, my;

  1031. 

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

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

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

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

  1036. 

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

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

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

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

  1041. 

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

  1043.                     /* special rounding for h263 */

  1044.                     dxy = 0;

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

  1046.                         dxy |= 1;

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

  1048.                         dxy |= 2;

  1049.                     mx = motion_x >> 2;

  1050.                     my = motion_y >> 2;

  1051.                 } else {

  1052.                     mx = motion_x / 2;

  1053.                     my = motion_y / 2;

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

  1055.                     mx >>= 1;

  1056.                     my >>= 1;

  1057.                 }

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

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

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

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

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

  1063.             }

  1064.             emms_c();

  1065.             

  1066. #if 0

  1067.             {

  1068.                 float adap_parm;

  1069.                 

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

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

  1072.             

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

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

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

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

  1077.             }

  1078. #endif

  1079.             /* DCT & quantize */

  1080.             if (s->h263_msmpeg4) {

  1081.                 msmpeg4_dc_scale(s);

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

  1083.                 h263_dc_scale(s);

  1084.             } else {

  1085.                 /* default quantization values */

  1086.                 s->y_dc_scale = 8;

  1087.                 s->c_dc_scale = 8;

  1088.             }

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

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

  1091.             }

  1092. 

  1093.             /* huffman encode */

  1094.             switch(s->out_format) {

  1095.             case FMT_MPEG1:

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

  1097.                 break;

  1098.             case FMT_H263:

  1099.                 if (s->h263_msmpeg4)

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

  1101.                 else

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

  1103.                 break;

  1104.             case FMT_MJPEG:

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

  1106.                 break;

  1107.             }

  1108. 

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

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

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

  1112. 

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

  1114.         }

  1115. 

  1116. 

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

  1118.         if (s->rtp_mode) {

  1119.             if (!mb_y)

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

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

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

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

  1124.             }

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

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

  1127.             s->first_gob_line = 0;

  1128.         }

  1129.     }

  1130.     

  1131.     if (s->h263_msmpeg4) 

  1132.         msmpeg4_encode_ext_header(s);

  1133. 

  1134.     //if (s->gob_number)

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

  1136.     

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

  1138.     if (s->rtp_mode) {

  1139.         flush_put_bits(&s->pb);

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

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

  1142.         if (s->rtp_callback)

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

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

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

  1146.     }

  1147. 

  1148. }

  1149. 

  1150. static int dct_quantize_c(MpegEncContext *s, 

  1151.                         DCTELEM *block, int n,

  1152.                         int qscale)

  1153. {

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

  1155.     const int *qmat;

  1156.     int minLevel, maxLevel;

  1157. 

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

  1159. 	/* mpeg4 */

  1160.         minLevel= -2048;

  1161. 	maxLevel= 2047;

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

  1163. 	/* mpeg1 */

  1164.         minLevel= -255;

  1165. 	maxLevel= 255;

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

  1167. 	/* (m)jpeg */

  1168.         minLevel= -1023;

  1169. 	maxLevel= 1023;

  1170.     }else{

  1171. 	/* h263 / msmpeg4 */

  1172.         minLevel= -128;

  1173. 	maxLevel= 127;

  1174.     }

  1175. 

  1176.     av_fdct (block);

  1177. 

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

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

  1180.     block_permute(block);

  1181. 

  1182.     if (s->mb_intra) {

  1183.         if (n < 4)

  1184.             q = s->y_dc_scale;

  1185.         else

  1186.             q = s->c_dc_scale;

  1187.         q = q << 3;

  1188.         

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

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

  1191.         i = 1;

  1192.         last_non_zero = 0;

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

  1194.             qmat = s->q_non_intra_matrix;

  1195.         } else {

  1196.             qmat = s->q_intra_matrix;

  1197.         }

  1198.     } else {

  1199.         i = 0;

  1200.         last_non_zero = -1;

  1201.         qmat = s->q_non_intra_matrix;

  1202.     }

  1203. 

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

  1205.         j = zigzag_direct[i];

  1206.         level = block[j];

  1207.         level = level * qmat[j];

  1208. #ifdef PARANOID

  1209.         {

  1210.             static int count = 0;

  1211.             int level1, level2, qmat1;

  1212.             double val;

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

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

  1215.             } else {

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

  1217.             }

  1218.             if (av_fdct != jpeg_fdct_ifast)

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

  1220.             else

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

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

  1223.             level1 = (int)val;

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

  1225.             if (level1 != level2) {

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

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

  1228.                         val);

  1229.                 count++;

  1230.             }

  1231. 

  1232.         }

  1233. #endif

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

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

  1236.            (QMAT_SHIFT - 3)))

  1237.         */

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

  1239.             level) {

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

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

  1242.                mpeg1: -255..255

  1243.                mpeg2: -2048..2047

  1244.                h263:  -128..127

  1245.                mpeg4: -2048..2047

  1246.             */

  1247.             if (level > maxLevel)

  1248.                 level = maxLevel;

  1249.             else if (level < minLevel)

  1250.                 level = minLevel;

  1251. 

  1252.             block[j] = level;

  1253.             last_non_zero = i;

  1254.         } else {

  1255.             block[j] = 0;

  1256.         }

  1257.     }

  1258.     return last_non_zero;

  1259. }

  1260. 

  1261. static void dct_unquantize_mpeg1_c(MpegEncContext *s, 

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

  1263. {

  1264.     int i, level, nCoeffs;

  1265.     const UINT16 *quant_matrix;

  1266. 

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

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

  1269.     

  1270.     if (s->mb_intra) {

  1271.         if (n < 4) 

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

  1273.         else

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

  1275.         /* XXX: only mpeg1 */

  1276.         quant_matrix = s->intra_matrix;

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

  1278.             int j= zigzag_direct[i];

  1279.             level = block[j];

  1280.             if (level) {

  1281.                 if (level < 0) {

  1282.                     level = -level;

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

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

  1285.                     level = -level;

  1286.                 } else {

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

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

  1289.                 }

  1290. #ifdef PARANOID

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

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

  1293. #endif

  1294.                 block[j] = level;

  1295.             }

  1296.         }

  1297.     } else {

  1298.         i = 0;

  1299.         quant_matrix = s->non_intra_matrix;

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

  1301.             int j= zigzag_direct[i];

  1302.             level = block[j];

  1303.             if (level) {

  1304.                 if (level < 0) {

  1305.                     level = -level;

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

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

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

  1309.                     level = -level;

  1310.                 } else {

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

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

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

  1314.                 }

  1315. #ifdef PARANOID

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

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

  1318. #endif

  1319.                 block[j] = level;

  1320.             }

  1321.         }

  1322.     }

  1323. }

  1324. 

  1325. static void dct_unquantize_h263_c(MpegEncContext *s, 

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

  1327. {

  1328.     int i, level, qmul, qadd;

  1329.     int nCoeffs;

  1330.     

  1331.     if (s->mb_intra) {

  1332.         if (!s->h263_aic) {

  1333.             if (n < 4) 

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

  1335.             else

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

  1337.         }

  1338.         i = 1;

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

  1340.     } else {

  1341.         i = 0;

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

  1343.     }

  1344. 

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

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

  1347.         qadd = 0;

  1348.     else

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

  1350. 

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

  1352.         level = block[i];

  1353.         if (level) {

  1354.             if (level < 0) {

  1355.                 level = level * qmul - qadd;

  1356.             } else {

  1357.                 level = level * qmul + qadd;

  1358.             }

  1359. #ifdef PARANOID

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

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

  1362. #endif

  1363.             block[i] = level;

  1364.         }

  1365.     }

  1366. }

  1367. 

  1368. /* rate control */

  1369. 

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

  1371. #define I_FRAME_SIZE_RATIO 3.0

  1372. #define QSCALE_K           20

  1373. 

  1374. static void rate_control_init(MpegEncContext *s)

  1375. {

  1376.     s->wanted_bits = 0;

  1377. 

  1378.     if (s->intra_only) {

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

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

  1381.     } else {

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

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

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

  1385.     }

  1386.     

  1387. #if defined(DEBUG)

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

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

  1390. #endif

  1391. }

  1392. 

  1393. 

  1394. /*

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

  1396.  * change the qscale at every macroblock.

  1397.  */

  1398. static int rate_estimate_qscale(MpegEncContext *s)

  1399. {

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

  1401.     float q;

  1402.     int qscale, qmin;

  1403. 

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

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

  1406.     } else {

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

  1408.     }

  1409.     diff = s->wanted_bits - total_bits;

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

  1411.     /* adjust for I frame */

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

  1413.         q /= I_FRAME_SIZE_RATIO;

  1414.     }

  1415. 

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

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

  1418.     qmin = 3;

  1419.     if (q < qmin)

  1420.         q = qmin;

  1421.     else if (q > 31)

  1422.         q = 31;

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

  1424. #if defined(DEBUG)

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

  1426.            s->picture_number, 

  1427.            (double)total_bits, 

  1428.            (double)s->wanted_bits,

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

  1430.            total_bits / s->picture_number, 

  1431.            (int)diff, q);

  1432. #endif

  1433.     return qscale;

  1434. }

  1435. 

  1436. AVCodec mpeg1video_encoder = {

  1437.     "mpeg1video",

  1438.     CODEC_TYPE_VIDEO,

  1439.     CODEC_ID_MPEG1VIDEO,

  1440.     sizeof(MpegEncContext),

  1441.     MPV_encode_init,

  1442.     MPV_encode_picture,

  1443.     MPV_encode_end,

  1444. };

  1445. 

  1446. AVCodec h263_encoder = {

  1447.     "h263",

  1448.     CODEC_TYPE_VIDEO,

  1449.     CODEC_ID_H263,

  1450.     sizeof(MpegEncContext),

  1451.     MPV_encode_init,

  1452.     MPV_encode_picture,

  1453.     MPV_encode_end,

  1454. };

  1455. 

  1456. AVCodec h263p_encoder = {

  1457.     "h263p",

  1458.     CODEC_TYPE_VIDEO,

  1459.     CODEC_ID_H263P,

  1460.     sizeof(MpegEncContext),

  1461.     MPV_encode_init,

  1462.     MPV_encode_picture,

  1463.     MPV_encode_end,

  1464. };

  1465. 

  1466. AVCodec rv10_encoder = {

  1467.     "rv10",

  1468.     CODEC_TYPE_VIDEO,

  1469.     CODEC_ID_RV10,

  1470.     sizeof(MpegEncContext),

  1471.     MPV_encode_init,

  1472.     MPV_encode_picture,

  1473.     MPV_encode_end,

  1474. };

  1475. 

  1476. AVCodec mjpeg_encoder = {

  1477.     "mjpeg",

  1478.     CODEC_TYPE_VIDEO,

  1479.     CODEC_ID_MJPEG,

  1480.     sizeof(MpegEncContext),

  1481.     MPV_encode_init,

  1482.     MPV_encode_picture,

  1483.     MPV_encode_end,

  1484. };

  1485. 

  1486. AVCodec mpeg4_encoder = {

  1487.     "mpeg4",

  1488.     CODEC_TYPE_VIDEO,

  1489.     CODEC_ID_MPEG4,

  1490.     sizeof(MpegEncContext),

  1491.     MPV_encode_init,

  1492.     MPV_encode_picture,

  1493.     MPV_encode_end,

  1494. };

  1495. 

  1496. AVCodec msmpeg4_encoder = {

  1497.     "msmpeg4",

  1498.     CODEC_TYPE_VIDEO,

  1499.     CODEC_ID_MSMPEG4,

  1500.     sizeof(MpegEncContext),

  1501.     MPV_encode_init,

  1502.     MPV_encode_picture,

  1503.     MPV_encode_end,

  1504. };