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.
461 Commits
32 Branches
1.2GB
Tree: cc9ba006ec
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cc9ba006ec'
${ noResults }
FFmpeg/libavcodec/mpegvideo.c

1511 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.     if (avctx->get_psnr) {

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

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

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

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

  530.     }

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

  532. }

  533. 

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

  535. {

  536.     if (a < amin)

  537.         return amin;

  538.     else if (a > amax)

  539.         return amax;

  540.     else

  541.         return a;

  542. }

  543. 

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

  545. static inline void mpeg_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 field_based, op_pixels_func *pix_op,

  550.                                int motion_x, int motion_y, int h)

  551. {

  552.     UINT8 *ptr;

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

  554.     

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

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

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

  558.                 

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

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

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

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

  563.         dxy &= ~1;

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

  565.     if (src_y == height)

  566.         dxy &= ~2;

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

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

  569.     dest_y += dest_offset;

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

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

  572. 

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

  574.         dxy = 0;

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

  576.             dxy |= 1;

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

  578.             dxy |= 2;

  579.         mx = motion_x >> 2;

  580.         my = motion_y >> 2;

  581.     } else {

  582.         mx = motion_x / 2;

  583.         my = motion_y / 2;

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

  585.         mx >>= 1;

  586.         my >>= 1;

  587.     }

  588.     

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

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

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

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

  593.         dxy &= ~1;

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

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

  596.         dxy &= ~2;

  597. 

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

  599.     ptr = ref_picture[1] + offset;

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

  601.     ptr = ref_picture[2] + offset;

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

  603. }

  604. 

  605. static inline void MPV_motion(MpegEncContext *s, 

  606.                               UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,

  607.                               int dir, UINT8 **ref_picture, 

  608.                               op_pixels_func *pix_op)

  609. {

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

  611.     int mb_x, mb_y, i;

  612.     UINT8 *ptr, *dest;

  613. 

  614.     mb_x = s->mb_x;

  615.     mb_y = s->mb_y;

  616. 

  617.     switch(s->mv_type) {

  618.     case MV_TYPE_16X16:

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

  620.                     ref_picture, 0,

  621.                     0, pix_op,

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

  623.         break;

  624.     case MV_TYPE_8X8:

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

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

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

  628. 

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

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

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

  632.                     

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

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

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

  636.                 dxy &= ~1;

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

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

  639.                 dxy &= ~2;

  640.                     

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

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

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

  644.         }

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

  646.            with a special rounding */

  647.         mx = 0;

  648.         my = 0;

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

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

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

  652.         }

  653.         if (mx >= 0)

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

  655.         else {

  656.             mx = -mx;

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

  658.         }

  659.         if (my >= 0)

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

  661.         else {

  662.             my = -my;

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

  664.         }

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

  666.         mx >>= 1;

  667.         my >>= 1;

  668. 

  669.         src_x = mb_x * 8 + mx;

  670.         src_y = mb_y * 8 + my;

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

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

  673.             dxy &= ~1;

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

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

  676.             dxy &= ~2;

  677.         

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

  679.         ptr = ref_picture[1] + offset;

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

  681.         ptr = ref_picture[2] + offset;

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

  683.         break;

  684.     case MV_TYPE_FIELD:

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

  686.             /* top field */

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

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

  689.                         1, pix_op,

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

  691.             /* bottom field */

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

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

  694.                         1, pix_op,

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

  696.         } else {

  697.             

  698. 

  699.         }

  700.         break;

  701.     }

  702. }

  703. 

  704. 

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

  706. static inline void put_dct(MpegEncContext *s, 

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

  708. {

  709.     if (!s->mpeg2)

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

  711.     ff_idct (block);

  712.     put_pixels_clamped(block, dest, line_size);

  713. }

  714. 

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

  716. static inline void add_dct(MpegEncContext *s, 

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

  718. {

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

  720.         if (!s->mpeg2)

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

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

  723.         ff_idct (block);

  724.         add_pixels_clamped(block, dest, line_size);

  725.     }

  726. }

  727. 

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

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

  730. 

  731.    Important variables used:

  732.    s->mb_intra : true if intra macroblock

  733.    s->mv_dir   : motion vector direction

  734.    s->mv_type  : motion vector type

  735.    s->mv       : motion vector

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

  737.  */

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

  739. {

  740.     int mb_x, mb_y;

  741.     int dct_linesize, dct_offset;

  742.     op_pixels_func *op_pix;

  743. 

  744.     mb_x = s->mb_x;

  745.     mb_y = s->mb_y;

  746. 

  747. #ifdef FF_POSTPROCESS

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

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

  750. #endif

  751. 

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

  753.     if (!s->mb_intra) {

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

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

  756.           {

  757.             int wrap, xy, v;

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

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

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

  761.             v = 1024;

  762.             

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

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

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

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

  767.             /* ac pred */

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

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

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

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

  772.             if (s->h263_msmpeg4) {

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

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

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

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

  777.             }

  778.             /* chroma */

  779.             wrap = s->mb_width + 2;

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

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

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

  783.             /* ac pred */

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

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

  786.           }

  787.         } else {

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

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

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

  791.         }

  792.     }

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

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

  795. 

  796.     /* update motion predictor */

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

  798.         int xy, wrap, motion_x, motion_y;

  799.         

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

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

  802.         if (s->mb_intra) {

  803.             motion_x = 0;

  804.             motion_y = 0;

  805.             goto motion_init;

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

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

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

  809.         motion_init:

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

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

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

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

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

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

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

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

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

  819.         }

  820.     }

  821.     

  822.     if (!s->intra_only) {

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

  824.         UINT8 *mbskip_ptr;

  825. 

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

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

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

  829.             if (s->mb_skiped) {

  830.                 s->mb_skiped = 0;

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

  832.                 if (*mbskip_ptr != 0) 

  833.                     goto the_end;

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

  835.             } else {

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

  837.             }

  838.         }

  839. 

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

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

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

  843. 

  844.         if (s->interlaced_dct) {

  845.             dct_linesize = s->linesize * 2;

  846.             dct_offset = s->linesize;

  847.         } else {

  848.             dct_linesize = s->linesize;

  849.             dct_offset = s->linesize * 8;

  850.         }

  851. 

  852.         if (!s->mb_intra) {

  853.             /* motion handling */

  854.             if (!s->no_rounding) 

  855.                 op_pix = put_pixels_tab;

  856.             else

  857.                 op_pix = put_no_rnd_pixels_tab;

  858. 

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

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

  861.                 if (!s->no_rounding) 

  862.                     op_pix = avg_pixels_tab;

  863.                 else

  864.                     op_pix = avg_no_rnd_pixels_tab;

  865.             }

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

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

  868.             }

  869. 

  870.             /* add dct residue */

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

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

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

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

  875. 

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

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

  878.         } else {

  879.             /* dct only in intra block */

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

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

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

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

  884. 

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

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

  887.         }

  888.     }

  889.  the_end:

  890.     emms_c();

  891. }

  892. 

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

  894. {

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

  896.     UINT8 *ptr;

  897.     int i, motion_x, motion_y;

  898. 

  899.     s->picture_number = picture_number;

  900.     if (!s->fixed_qscale) 

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

  902. 

  903.     /* precompute matrix */

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

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

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

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

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

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

  910.     } else {

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

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

  913.     }

  914. 

  915.     switch(s->out_format) {

  916.     case FMT_MJPEG:

  917.         mjpeg_picture_header(s);

  918.         break;

  919.     case FMT_H263:

  920.         if (s->h263_msmpeg4) 

  921.             msmpeg4_encode_picture_header(s, picture_number);

  922.         else if (s->h263_pred)

  923.             mpeg4_encode_picture_header(s, picture_number);

  924.         else if (s->h263_rv10) 

  925.             rv10_encode_picture_header(s, picture_number);

  926.         else

  927.             h263_encode_picture_header(s, picture_number);

  928.         break;

  929.     case FMT_MPEG1:

  930.         mpeg1_encode_picture_header(s, picture_number);

  931.         break;

  932.     }

  933.         

  934.     /* init last dc values */

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

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

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

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

  939.     s->mb_incr = 1;

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

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

  942.     s->mv_type = MV_TYPE_16X16;

  943.     s->mv_dir = MV_DIR_FORWARD;

  944. 

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

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

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

  948.             s->gob_index = 1;

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

  950.             s->gob_index = 2;

  951.         else

  952.             s->gob_index = 4;

  953.     }

  954.     

  955.     /* Reset the average MB variance */

  956.     s->avg_mb_var = 0;

  957.     

  958.     /* Estimate motion for every MB */

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

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

  961.             s->mb_x = mb_x;

  962.             s->mb_y = mb_y;

  963. 

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

  965.             motion_x = 0;

  966.             motion_y = 0;

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

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

  969.                                               &motion_x,

  970.                                               &motion_y);

  971.             } else {

  972.                 s->mb_intra = 1;

  973.             }

  974.             /* Store MB type and MV */

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

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

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

  978.         }

  979.     }

  980.     

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

  982.     

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

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

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

  986.         if (s->rtp_mode) {

  987.             if (!mb_y) {

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

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

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

  991.                 last_gob = h263_encode_gob_header(s, mb_y);

  992.                 if (last_gob) {

  993.                     s->first_gob_line = 1;

  994.                 }

  995.             }

  996.         }

  997.         

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

  999. 

  1000.             s->mb_x = mb_x;

  1001.             s->mb_y = mb_y;

  1002. #if 0

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

  1004.             motion_x = 0;

  1005.             motion_y = 0;

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

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

  1008.                                               &motion_x,

  1009.                                               &motion_y);

  1010.             } else {

  1011.                 s->mb_intra = 1;

  1012.             }

  1013. #endif

  1014. 

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

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

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

  1018.             

  1019.             /* get the pixels */

  1020.             wrap = s->linesize;

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

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

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

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

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

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

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

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

  1029. 

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

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

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

  1033. 

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

  1035.             if (!s->mb_intra) {

  1036.                 int dxy, offset, mx, my;

  1037. 

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

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

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

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

  1042. 

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

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

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

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

  1047. 

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

  1049.                     /* special rounding for h263 */

  1050.                     dxy = 0;

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

  1052.                         dxy |= 1;

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

  1054.                         dxy |= 2;

  1055.                     mx = motion_x >> 2;

  1056.                     my = motion_y >> 2;

  1057.                 } else {

  1058.                     mx = motion_x / 2;

  1059.                     my = motion_y / 2;

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

  1061.                     mx >>= 1;

  1062.                     my >>= 1;

  1063.                 }

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

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

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

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

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

  1069.             }

  1070.             emms_c();

  1071.             

  1072. #if 0

  1073.             {

  1074.                 float adap_parm;

  1075.                 

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

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

  1078.             

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

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

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

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

  1083.             }

  1084. #endif

  1085.             /* DCT & quantize */

  1086.             if (s->h263_msmpeg4) {

  1087.                 msmpeg4_dc_scale(s);

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

  1089.                 h263_dc_scale(s);

  1090.             } else {

  1091.                 /* default quantization values */

  1092.                 s->y_dc_scale = 8;

  1093.                 s->c_dc_scale = 8;

  1094.             }

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

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

  1097.             }

  1098. 

  1099.             /* huffman encode */

  1100.             switch(s->out_format) {

  1101.             case FMT_MPEG1:

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

  1103.                 break;

  1104.             case FMT_H263:

  1105.                 if (s->h263_msmpeg4)

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

  1107.                 else

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

  1109.                 break;

  1110.             case FMT_MJPEG:

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

  1112.                 break;

  1113.             }

  1114. 

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

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

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

  1118. 

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

  1120.         }

  1121. 

  1122. 

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

  1124.         if (s->rtp_mode) {

  1125.             if (!mb_y)

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

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

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

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

  1130.             }

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

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

  1133.             s->first_gob_line = 0;

  1134.         }

  1135.     }

  1136.     

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

  1138.         msmpeg4_encode_ext_header(s);

  1139. 

  1140.     //if (s->gob_number)

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

  1142.     

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

  1144.     if (s->rtp_mode) {

  1145.         flush_put_bits(&s->pb);

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

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

  1148.         if (s->rtp_callback)

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

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

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

  1152.     }

  1153. 

  1154. }

  1155. 

  1156. static int dct_quantize_c(MpegEncContext *s, 

  1157.                         DCTELEM *block, int n,

  1158.                         int qscale)

  1159. {

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

  1161.     const int *qmat;

  1162.     int minLevel, maxLevel;

  1163. 

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

  1165. 	/* mpeg4 */

  1166.         minLevel= -2048;

  1167. 	maxLevel= 2047;

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

  1169. 	/* mpeg1 */

  1170.         minLevel= -255;

  1171. 	maxLevel= 255;

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

  1173. 	/* (m)jpeg */

  1174.         minLevel= -1023;

  1175. 	maxLevel= 1023;

  1176.     }else{

  1177. 	/* h263 / msmpeg4 */

  1178.         minLevel= -128;

  1179. 	maxLevel= 127;

  1180.     }

  1181. 

  1182.     av_fdct (block);

  1183. 

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

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

  1186.     block_permute(block);

  1187. 

  1188.     if (s->mb_intra) {

  1189.         if (n < 4)

  1190.             q = s->y_dc_scale;

  1191.         else

  1192.             q = s->c_dc_scale;

  1193.         q = q << 3;

  1194.         

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

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

  1197.         i = 1;

  1198.         last_non_zero = 0;

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

  1200.             qmat = s->q_non_intra_matrix;

  1201.         } else {

  1202.             qmat = s->q_intra_matrix;

  1203.         }

  1204.     } else {

  1205.         i = 0;

  1206.         last_non_zero = -1;

  1207.         qmat = s->q_non_intra_matrix;

  1208.     }

  1209. 

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

  1211.         j = zigzag_direct[i];

  1212.         level = block[j];

  1213.         level = level * qmat[j];

  1214. #ifdef PARANOID

  1215.         {

  1216.             static int count = 0;

  1217.             int level1, level2, qmat1;

  1218.             double val;

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

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

  1221.             } else {

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

  1223.             }

  1224.             if (av_fdct != jpeg_fdct_ifast)

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

  1226.             else

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

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

  1229.             level1 = (int)val;

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

  1231.             if (level1 != level2) {

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

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

  1234.                         val);

  1235.                 count++;

  1236.             }

  1237. 

  1238.         }

  1239. #endif

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

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

  1242.            (QMAT_SHIFT - 3)))

  1243.         */

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

  1245.             level) {

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

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

  1248.                mpeg1: -255..255

  1249.                mpeg2: -2048..2047

  1250.                h263:  -128..127

  1251.                mpeg4: -2048..2047

  1252.             */

  1253.             if (level > maxLevel)

  1254.                 level = maxLevel;

  1255.             else if (level < minLevel)

  1256.                 level = minLevel;

  1257. 

  1258.             block[j] = level;

  1259.             last_non_zero = i;

  1260.         } else {

  1261.             block[j] = 0;

  1262.         }

  1263.     }

  1264.     return last_non_zero;

  1265. }

  1266. 

  1267. static void dct_unquantize_mpeg1_c(MpegEncContext *s, 

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

  1269. {

  1270.     int i, level, nCoeffs;

  1271.     const UINT16 *quant_matrix;

  1272. 

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

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

  1275.     

  1276.     if (s->mb_intra) {

  1277.         if (n < 4) 

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

  1279.         else

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

  1281.         /* XXX: only mpeg1 */

  1282.         quant_matrix = s->intra_matrix;

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

  1284.             int j= zigzag_direct[i];

  1285.             level = block[j];

  1286.             if (level) {

  1287.                 if (level < 0) {

  1288.                     level = -level;

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

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

  1291.                     level = -level;

  1292.                 } else {

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

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

  1295.                 }

  1296. #ifdef PARANOID

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

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

  1299. #endif

  1300.                 block[j] = level;

  1301.             }

  1302.         }

  1303.     } else {

  1304.         i = 0;

  1305.         quant_matrix = s->non_intra_matrix;

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

  1307.             int j= zigzag_direct[i];

  1308.             level = block[j];

  1309.             if (level) {

  1310.                 if (level < 0) {

  1311.                     level = -level;

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

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

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

  1315.                     level = -level;

  1316.                 } else {

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

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

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

  1320.                 }

  1321. #ifdef PARANOID

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

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

  1324. #endif

  1325.                 block[j] = level;

  1326.             }

  1327.         }

  1328.     }

  1329. }

  1330. 

  1331. static void dct_unquantize_h263_c(MpegEncContext *s, 

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

  1333. {

  1334.     int i, level, qmul, qadd;

  1335.     int nCoeffs;

  1336.     

  1337.     if (s->mb_intra) {

  1338.         if (!s->h263_aic) {

  1339.             if (n < 4) 

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

  1341.             else

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

  1343.         }

  1344.         i = 1;

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

  1346.     } else {

  1347.         i = 0;

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

  1349.     }

  1350. 

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

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

  1353.         qadd = 0;

  1354.     else

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

  1356. 

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

  1358.         level = block[i];

  1359.         if (level) {

  1360.             if (level < 0) {

  1361.                 level = level * qmul - qadd;

  1362.             } else {

  1363.                 level = level * qmul + qadd;

  1364.             }

  1365. #ifdef PARANOID

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

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

  1368. #endif

  1369.             block[i] = level;

  1370.         }

  1371.     }

  1372. }

  1373. 

  1374. /* rate control */

  1375. 

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

  1377. #define I_FRAME_SIZE_RATIO 3.0

  1378. #define QSCALE_K           20

  1379. 

  1380. static void rate_control_init(MpegEncContext *s)

  1381. {

  1382.     s->wanted_bits = 0;

  1383. 

  1384.     if (s->intra_only) {

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

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

  1387.     } else {

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

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

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

  1391.     }

  1392.     

  1393. #if defined(DEBUG)

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

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

  1396. #endif

  1397. }

  1398. 

  1399. 

  1400. /*

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

  1402.  * change the qscale at every macroblock.

  1403.  */

  1404. static int rate_estimate_qscale(MpegEncContext *s)

  1405. {

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

  1407.     float q;

  1408.     int qscale, qmin;

  1409. 

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

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

  1412.     } else {

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

  1414.     }

  1415.     diff = s->wanted_bits - total_bits;

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

  1417.     /* adjust for I frame */

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

  1419.         q /= I_FRAME_SIZE_RATIO;

  1420.     }

  1421. 

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

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

  1424.     qmin = 3;

  1425.     if (q < qmin)

  1426.         q = qmin;

  1427.     else if (q > 31)

  1428.         q = 31;

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

  1430. #if defined(DEBUG)

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

  1432.            s->picture_number, 

  1433.            (double)total_bits, 

  1434.            (double)s->wanted_bits,

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

  1436.            total_bits / s->picture_number, 

  1437.            (int)diff, q);

  1438. #endif

  1439.     return qscale;

  1440. }

  1441. 

  1442. AVCodec mpeg1video_encoder = {

  1443.     "mpeg1video",

  1444.     CODEC_TYPE_VIDEO,

  1445.     CODEC_ID_MPEG1VIDEO,

  1446.     sizeof(MpegEncContext),

  1447.     MPV_encode_init,

  1448.     MPV_encode_picture,

  1449.     MPV_encode_end,

  1450. };

  1451. 

  1452. AVCodec h263_encoder = {

  1453.     "h263",

  1454.     CODEC_TYPE_VIDEO,

  1455.     CODEC_ID_H263,

  1456.     sizeof(MpegEncContext),

  1457.     MPV_encode_init,

  1458.     MPV_encode_picture,

  1459.     MPV_encode_end,

  1460. };

  1461. 

  1462. AVCodec h263p_encoder = {

  1463.     "h263p",

  1464.     CODEC_TYPE_VIDEO,

  1465.     CODEC_ID_H263P,

  1466.     sizeof(MpegEncContext),

  1467.     MPV_encode_init,

  1468.     MPV_encode_picture,

  1469.     MPV_encode_end,

  1470. };

  1471. 

  1472. AVCodec rv10_encoder = {

  1473.     "rv10",

  1474.     CODEC_TYPE_VIDEO,

  1475.     CODEC_ID_RV10,

  1476.     sizeof(MpegEncContext),

  1477.     MPV_encode_init,

  1478.     MPV_encode_picture,

  1479.     MPV_encode_end,

  1480. };

  1481. 

  1482. AVCodec mjpeg_encoder = {

  1483.     "mjpeg",

  1484.     CODEC_TYPE_VIDEO,

  1485.     CODEC_ID_MJPEG,

  1486.     sizeof(MpegEncContext),

  1487.     MPV_encode_init,

  1488.     MPV_encode_picture,

  1489.     MPV_encode_end,

  1490. };

  1491. 

  1492. AVCodec mpeg4_encoder = {

  1493.     "mpeg4",

  1494.     CODEC_TYPE_VIDEO,

  1495.     CODEC_ID_MPEG4,

  1496.     sizeof(MpegEncContext),

  1497.     MPV_encode_init,

  1498.     MPV_encode_picture,

  1499.     MPV_encode_end,

  1500. };

  1501. 

  1502. AVCodec msmpeg4_encoder = {

  1503.     "msmpeg4",

  1504.     CODEC_TYPE_VIDEO,

  1505.     CODEC_ID_MSMPEG4,

  1506.     sizeof(MpegEncContext),

  1507.     MPV_encode_init,

  1508.     MPV_encode_picture,

  1509.     MPV_encode_end,

  1510. };