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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
mpegvideo.c
资源名称：ffh264lib_0510.zip　[点击查看]
上传用户：jylinhe
上传日期：2022-07-11
资源大小：334k
文件大小：89k
源码类别：

多媒体编程

开发平台：

Visual C++

mpegvideo.c：源码内容
  1. /*
  2.  * The simplest mpeg encoder (well, it was the simplest!)
  3.  * Copyright (c) 2000,2001 Fabrice Bellard.
  4.  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
  5.  *
  6.  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
  7.  *
  8.  * This file is part of FFmpeg.
  9.  *
  10.  * FFmpeg is free software; you can redistribute it and/or
  11.  * modify it under the terms of the GNU Lesser General Public
  12.  * License as published by the Free Software Foundation; either
  13.  * version 2.1 of the License, or (at your option) any later version.
  14.  *
  15.  * FFmpeg is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18.  * Lesser General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU Lesser General Public
  21.  * License along with FFmpeg; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23.  */
  25. /**
  26.  * @file mpegvideo.c
  27.  * The simplest mpeg encoder (well, it was the simplest!).
  28.  */
  30. #include "dsputil.h"
  31. #include "internal.h"
  32. //#include "integer.h"
  33. #include "mpegvideo.h"
  34. #include "mpegvideo_common.h"
  35. //#include "mjpegenc.h"
  36. //#include "msmpeg4.h"
  37. //#include "faandct.h"
  38. #include <limits.h>
  40. //#undef NDEBUG
  41. //#include <assert.h>
  43. static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
  44.                                    DCTELEM *block, int n, int qscale);
  45. static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
  46.                                    DCTELEM *block, int n, int qscale);
  47. static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
  48.                                    DCTELEM *block, int n, int qscale);
  49. static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
  50.                                    DCTELEM *block, int n, int qscale);
  51. static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
  52.                                    DCTELEM *block, int n, int qscale);
  53. static void dct_unquantize_h263_intra_c(MpegEncContext *s,
  54.                                   DCTELEM *block, int n, int qscale);
  55. static void dct_unquantize_h263_inter_c(MpegEncContext *s,
  56.                                   DCTELEM *block, int n, int qscale);
  58. int  XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
  59. void XVMC_field_end(MpegEncContext *s);
  60. void XVMC_decode_mb(MpegEncContext *s);
  63. /* enable all paranoid tests for rounding, overflows, etc... */
  64. //#define PARANOID
  66. //#define DEBUG
  69. static const uint8_t ff_default_chroma_qscale_table[32]={
  70. //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  71.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
  72. };
  74. const uint8_t ff_mpeg1_dc_scale_table[128]={
  75. //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  76.     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  77.     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  78.     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  79.     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  80. };
  83. const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
  84.     int i;
  86.     assert(p<=end);
  87.     if(p>=end)
  88.         return end;
  90.     for(i=0; i<3; i++){
  91.         uint32_t tmp= *state << 8;
  92.         *state= tmp + *(p++);
  93.         if(tmp == 0x100 || p==end)
  94.             return p;
  95.     }
  97.     while(p<end){
  98.         if     (p[-1] > 1      ) p+= 3;
  99.         else if(p[-2]          ) p+= 2;
  100.         else if(p[-3]|(p[-1]-1)) p++;
  101.         else{
  102.             p++;
  103.             break;
  104.         }
  105.     }
  107.     p= FFMIN(p, end)-4;
  108.     *state= AV_RB32(p);
  110.     return p+4;
  111. }
  113. /* init common dct for both encoder and decoder */
  114. int ff_dct_common_init(MpegEncContext *s)
  115. {
  116.     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
  117.     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
  118.     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
  119.     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
  120.     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
  121.     if(s->flags & CODEC_FLAG_BITEXACT)
  122.         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
  123.     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
  125. #if defined(HAVE_MMX)
  126.     MPV_common_init_mmx(s);
  127. #elif defined(ARCH_ALPHA)
  128.     MPV_common_init_axp(s);
  129. #elif defined(CONFIG_MLIB)
  130.     MPV_common_init_mlib(s);
  131. #elif defined(HAVE_MMI)
  132.     MPV_common_init_mmi(s);
  133. #elif defined(ARCH_ARM)
  134.     MPV_common_init_arm(s);
  135. #elif defined(HAVE_ALTIVEC)
  136.     MPV_common_init_altivec(s);
  137. #elif defined(ARCH_BFIN)
  138.     MPV_common_init_bfin(s);
  139. #endif
  141.     /* load & permutate scantables
  142.        note: only wmv uses different ones
  143.     */
  144.     if(s->alternate_scan){
  145.         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
  146.         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
  147.     }else{
  148.         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
  149.         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
  150.     }
  151.     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
  152.     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
  154.     return 0;
  155. }
  157. void ff_copy_picture(Picture *dst, Picture *src){
  158.     *dst = *src;
  159.     dst->type= FF_BUFFER_TYPE_COPY;
  160. }
  162. /**
  163.  * allocates a Picture
  164.  * The pixels are allocated/set by calling get_buffer() if shared=0
  165.  */
  166. int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
  167.     const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
  168.     const int mb_array_size= s->mb_stride*s->mb_height;
  169.     const int b8_array_size= s->b8_stride*s->mb_height*2;
  170.     const int b4_array_size= s->b4_stride*s->mb_height*4;
  171.     int i;
  172.     int r= -1;
  174.     if(shared){
  175.         assert(pic->data[0]);
  176.         assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
  177.         pic->type= FF_BUFFER_TYPE_SHARED;
  178.     }else{
  179.         assert(!pic->data[0]);
  181.         r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
  183.         if(r<0 || !pic->age || !pic->type || !pic->data[0]){
  184.             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)n", r, pic->age, pic->type, pic->data[0]);
  185.             return -1;
  186.         }
  188.         if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
  189.             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)n");
  190.             s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
  191.             return -1;
  192.         }
  194.         if(pic->linesize[1] != pic->linesize[2]){
  195.             av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)n");
  196.             s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
  197.             return -1;
  198.         }
  200.         s->linesize  = pic->linesize[0];
  201.         s->uvlinesize= pic->linesize[1];
  202.     }
  204.     if(pic->qscale_table==NULL){
  205.         if (s->encoding) {
  206.             CHECKED_ALLOCZ(pic->mb_var   , mb_array_size * sizeof(int16_t))
  207.             CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
  208.             CHECKED_ALLOCZ(pic->mb_mean  , mb_array_size * sizeof(int8_t))
  209.         }
  211.         CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
  212.         CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
  213.         CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
  214.         pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
  215.         if(s->out_format == FMT_H264){
  216.             for(i=0; i<2; i++){
  217.                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t))
  218.                 pic->motion_val[i]= pic->motion_val_base[i]+4;
  219.                 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
  220.             }
  221.             pic->motion_subsample_log2= 2;
  222.         }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
  223.             for(i=0; i<2; i++){
  224.                 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
  225.                 pic->motion_val[i]= pic->motion_val_base[i]+4;
  226.                 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
  227.             }
  228.             pic->motion_subsample_log2= 3;
  229.         }
  230.         if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
  231.             CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
  232.         }
  233.         pic->qstride= s->mb_stride;
  234.         CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
  235.     }
  237.     /* It might be nicer if the application would keep track of these
  238.      * but it would require an API change. */
  239.     memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
  240.     s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
  241.     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
  242.         pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
  244.     return 0;
  245. fail: //for the CHECKED_ALLOCZ macro
  246.     if(r>=0)
  247.         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
  248.     return -1;
  249. }
  251. /**
  252.  * deallocates a picture
  253.  */
  254. static void free_picture(MpegEncContext *s, Picture *pic){
  255.     int i;
  257.     if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
  258.         s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
  259.     }
  261.     av_freep(&pic->mb_var);
  262.     av_freep(&pic->mc_mb_var);
  263.     av_freep(&pic->mb_mean);
  264.     av_freep(&pic->mbskip_table);
  265.     av_freep(&pic->qscale_table);
  266.     av_freep(&pic->mb_type_base);
  267.     av_freep(&pic->dct_coeff);
  268.     av_freep(&pic->pan_scan);
  269.     pic->mb_type= NULL;
  270.     for(i=0; i<2; i++){
  271.         av_freep(&pic->motion_val_base[i]);
  272.         av_freep(&pic->ref_index[i]);
  273.     }
  275.     if(pic->type == FF_BUFFER_TYPE_SHARED){
  276.         for(i=0; i<4; i++){
  277.             pic->base[i]=
  278.             pic->data[i]= NULL;
  279.         }
  280.         pic->type= 0;
  281.     }
  282. }
  284. static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
  285.     int i;
  287.     // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
  288.     CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
  289.     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
  291.      //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
  292.     CHECKED_ALLOCZ(s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t))
  293.     s->me.temp=         s->me.scratchpad;
  294.     s->rd_scratchpad=   s->me.scratchpad;
  295.     s->b_scratchpad=    s->me.scratchpad;
  296.     s->obmc_scratchpad= s->me.scratchpad + 16;
  297.     if (s->encoding) {
  298.         CHECKED_ALLOCZ(s->me.map      , ME_MAP_SIZE*sizeof(uint32_t))
  299.         CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
  300.         if(s->avctx->noise_reduction){
  301.             CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
  302.         }
  303.     }
  304.     CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
  305.     s->block= s->blocks[0];
  307.     for(i=0;i<12;i++){
  308.         s->pblocks[i] = (short *)(&s->block[i]);
  309.     }
  310.     return 0;
  311. fail:
  312.     return -1; //free() through MPV_common_end()
  313. }
  315. static void free_duplicate_context(MpegEncContext *s){
  316.     if(s==NULL) return;
  318.     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
  319.     av_freep(&s->me.scratchpad);
  320.     s->me.temp=
  321.     s->rd_scratchpad=
  322.     s->b_scratchpad=
  323.     s->obmc_scratchpad= NULL;
  325.     av_freep(&s->dct_error_sum);
  326.     av_freep(&s->me.map);
  327.     av_freep(&s->me.score_map);
  328.     av_freep(&s->blocks);
  329.     s->block= NULL;
  330. }
  332. static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
  333. #define COPY(a) bak->a= src->a
  334.     COPY(allocated_edge_emu_buffer);
  335.     COPY(edge_emu_buffer);
  336.     COPY(me.scratchpad);
  337.     COPY(me.temp);
  338.     COPY(rd_scratchpad);
  339.     COPY(b_scratchpad);
  340.     COPY(obmc_scratchpad);
  341.     COPY(me.map);
  342.     COPY(me.score_map);
  343.     COPY(blocks);
  344.     COPY(block);
  345.     COPY(start_mb_y);
  346.     COPY(end_mb_y);
  347.     COPY(me.map_generation);
  348.     COPY(pb);
  349.     COPY(dct_error_sum);
  350.     COPY(dct_count[0]);
  351.     COPY(dct_count[1]);
  352. #undef COPY
  353. }
  355. void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
  356.     MpegEncContext bak;
  357.     int i;
  358.     //FIXME copy only needed parts
  359. //START_TIMER
  360.     backup_duplicate_context(&bak, dst);
  361.     memcpy(dst, src, sizeof(MpegEncContext));
  362.     backup_duplicate_context(dst, &bak);
  363.     for(i=0;i<12;i++){
  364.         dst->pblocks[i] = (short *)(&dst->block[i]);
  365.     }
  366. //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
  367. }
  369. /**
  370.  * sets the given MpegEncContext to common defaults (same for encoding and decoding).
  371.  * the changed fields will not depend upon the prior state of the MpegEncContext.
  372.  */
  373. void MPV_common_defaults(MpegEncContext *s){
  374.     s->y_dc_scale_table=
  375.     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
  376.     s->chroma_qscale_table= ff_default_chroma_qscale_table;
  377.     s->progressive_frame= 1;
  378.     s->progressive_sequence= 1;
  379.     s->picture_structure= PICT_FRAME;
  381.     s->coded_picture_number = 0;
  382.     s->picture_number = 0;
  383.     s->input_picture_number = 0;
  385.     s->picture_in_gop_number = 0;
  387.     s->f_code = 1;
  388.     s->b_code = 1;
  389. }
  391. /**
  392.  * sets the given MpegEncContext to defaults for decoding.
  393.  * the changed fields will not depend upon the prior state of the MpegEncContext.
  394.  */
  395. void MPV_decode_defaults(MpegEncContext *s){
  396.     MPV_common_defaults(s);
  397. }
  399. /**
  400.  * init common structure for both encoder and decoder.
  401.  * this assumes that some variables like width/height are already set
  402.  */
  403. int MPV_common_init(MpegEncContext *s)
  404. {
  405.     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
  407.     s->mb_height = (s->height + 15) / 16;
  409.     if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
  410.         av_log(s->avctx, AV_LOG_ERROR, "too many threadsn");
  411.         return -1;
  412.     }
  414.     if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
  415.         return -1;
  417.     dsputil_init(&s->dsp, s->avctx);
  418.     ff_dct_common_init(s);
  420.     s->flags= s->avctx->flags;
  421.     s->flags2= s->avctx->flags2;
  423.     s->mb_width  = (s->width  + 15) / 16;
  424.     s->mb_stride = s->mb_width + 1;
  425.     s->b8_stride = s->mb_width*2 + 1;
  426.     s->b4_stride = s->mb_width*4 + 1;
  427.     mb_array_size= s->mb_height * s->mb_stride;
  428.     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
  430.     /* set chroma shifts */
  431.     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
  432.                                                     &(s->chroma_y_shift) );
  434.     /* set default edge pos, will be overriden in decode_header if needed */
  435.     s->h_edge_pos= s->mb_width*16;
  436.     s->v_edge_pos= s->mb_height*16;
  438.     s->mb_num = s->mb_width * s->mb_height;
  440.     s->block_wrap[0]=
  441.     s->block_wrap[1]=
  442.     s->block_wrap[2]=
  443.     s->block_wrap[3]= s->b8_stride;
  444.     s->block_wrap[4]=
  445.     s->block_wrap[5]= s->mb_stride;
  447.     y_size = s->b8_stride * (2 * s->mb_height + 1);
  448.     c_size = s->mb_stride * (s->mb_height + 1);
  449.     yc_size = y_size + 2 * c_size;
  451.     /* convert fourcc to upper case */
  452.     s->codec_tag=          toupper( s->avctx->codec_tag     &0xFF)
  453.                         + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
  454.                         + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
  455.                         + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
  457.     s->stream_codec_tag=          toupper( s->avctx->stream_codec_tag     &0xFF)
  458.                                + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
  459.                                + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
  460.                                + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
  462.     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
  464.     CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
  465.     for(y=0; y<s->mb_height; y++){
  466.         for(x=0; x<s->mb_width; x++){
  467.             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
  468.         }
  469.     }
  470.     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
  472.     if (s->encoding) {
  473.         /* Allocate MV tables */
  474.         CHECKED_ALLOCZ(s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t))
  475.         CHECKED_ALLOCZ(s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
  476.         CHECKED_ALLOCZ(s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t))
  477.         CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
  478.         CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
  479.         CHECKED_ALLOCZ(s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t))
  480.         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
  481.         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
  482.         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
  483.         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
  484.         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
  485.         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
  487.         if(s->msmpeg4_version){
  488.             CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
  489.         }
  490.         CHECKED_ALLOCZ(s->avctx->stats_out, 256);
  492.         /* Allocate MB type table */
  493.         CHECKED_ALLOCZ(s->mb_type  , mb_array_size * sizeof(uint16_t)) //needed for encoding
  495.         CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
  497.         CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
  498.         CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
  499.         CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
  500.         CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
  501.         CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
  502.         CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
  504.         if(s->avctx->noise_reduction){
  505.             CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
  506.         }
  507.     }
  508.     CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
  510.     CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
  512.     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
  513.         /* interlaced direct mode decoding tables */
  514.             for(i=0; i<2; i++){
  515.                 int j, k;
  516.                 for(j=0; j<2; j++){
  517.                     for(k=0; k<2; k++){
  518.                         CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k]     , mv_table_size * 2 * sizeof(int16_t))
  519.                         s->b_field_mv_table[i][j][k]    = s->b_field_mv_table_base[i][j][k]     + s->mb_stride + 1;
  520.                     }
  521.                     CHECKED_ALLOCZ(s->b_field_select_table[i][j]     , mb_array_size * 2 * sizeof(uint8_t))
  522.                     CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j]     , mv_table_size * 2 * sizeof(int16_t))
  523.                     s->p_field_mv_table[i][j]    = s->p_field_mv_table_base[i][j]     + s->mb_stride + 1;
  524.                 }
  525.                 CHECKED_ALLOCZ(s->p_field_select_table[i]      , mb_array_size * 2 * sizeof(uint8_t))
  526.             }
  527.     }
  528.     if (s->out_format == FMT_H263) {
  529.         /* ac values */
  530.         CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
  531.         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
  532.         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
  533.         s->ac_val[2] = s->ac_val[1] + c_size;
  535.         /* cbp values */
  536.         CHECKED_ALLOCZ(s->coded_block_base, y_size);
  537.         s->coded_block= s->coded_block_base + s->b8_stride + 1;
  539.         /* cbp, ac_pred, pred_dir */
  540.         CHECKED_ALLOCZ(s->cbp_table  , mb_array_size * sizeof(uint8_t))
  541.         CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
  542.     }
  544.     if (s->h263_pred || s->h263_plus || !s->encoding) {
  545.         /* dc values */
  546.         //MN: we need these for error resilience of intra-frames
  547.         CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
  548.         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
  549.         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
  550.         s->dc_val[2] = s->dc_val[1] + c_size;
  551.         for(i=0;i<yc_size;i++)
  552.             s->dc_val_base[i] = 1024;
  553.     }
  555.     /* which mb is a intra block */
  556.     CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
  557.     memset(s->mbintra_table, 1, mb_array_size);
  559.     /* init macroblock skip table */
  560.     CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
  561.     //Note the +1 is for a quicker mpeg4 slice_end detection
  562.     CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
  564.     s->parse_context.state= -1;
  565.     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
  566.        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
  567.        s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
  568.        s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
  569.     }
  571.     s->context_initialized = 1;
  573.     s->thread_context[0]= s;
  574.     threads = s->avctx->thread_count;
  576.     for(i=1; i<threads; i++){
  577.         s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
  578.         memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
  579.     }
  581.     for(i=0; i<threads; i++){
  582.         if(init_duplicate_context(s->thread_context[i], s) < 0)
  583.            goto fail;
  584.         s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
  585.         s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
  586.     }
  588.     return 0;
  589.  fail:
  590.     MPV_common_end(s);
  591.     return -1;
  592. }
  594. /* init common structure for both encoder and decoder */
  595. void MPV_common_end(MpegEncContext *s)
  596. {
  597.     int i, j, k;
  599.     for(i=0; i<s->avctx->thread_count; i++){
  600.         free_duplicate_context(s->thread_context[i]);
  601.     }
  602.     for(i=1; i<s->avctx->thread_count; i++){
  603.         av_freep(&s->thread_context[i]);
  604.     }
  606.     av_freep(&s->parse_context.buffer);
  607.     s->parse_context.buffer_size=0;
  609.     av_freep(&s->mb_type);
  610.     av_freep(&s->p_mv_table_base);
  611.     av_freep(&s->b_forw_mv_table_base);
  612.     av_freep(&s->b_back_mv_table_base);
  613.     av_freep(&s->b_bidir_forw_mv_table_base);
  614.     av_freep(&s->b_bidir_back_mv_table_base);
  615.     av_freep(&s->b_direct_mv_table_base);
  616.     s->p_mv_table= NULL;
  617.     s->b_forw_mv_table= NULL;
  618.     s->b_back_mv_table= NULL;
  619.     s->b_bidir_forw_mv_table= NULL;
  620.     s->b_bidir_back_mv_table= NULL;
  621.     s->b_direct_mv_table= NULL;
  622.     for(i=0; i<2; i++){
  623.         for(j=0; j<2; j++){
  624.             for(k=0; k<2; k++){
  625.                 av_freep(&s->b_field_mv_table_base[i][j][k]);
  626.                 s->b_field_mv_table[i][j][k]=NULL;
  627.             }
  628.             av_freep(&s->b_field_select_table[i][j]);
  629.             av_freep(&s->p_field_mv_table_base[i][j]);
  630.             s->p_field_mv_table[i][j]=NULL;
  631.         }
  632.         av_freep(&s->p_field_select_table[i]);
  633.     }
  635.     av_freep(&s->dc_val_base);
  636.     av_freep(&s->ac_val_base);
  637.     av_freep(&s->coded_block_base);
  638.     av_freep(&s->mbintra_table);
  639.     av_freep(&s->cbp_table);
  640.     av_freep(&s->pred_dir_table);
  642.     av_freep(&s->mbskip_table);
  643.     av_freep(&s->prev_pict_types);
  644.     av_freep(&s->bitstream_buffer);
  645.     s->allocated_bitstream_buffer_size=0;
  647.     av_freep(&s->avctx->stats_out);
  648.     av_freep(&s->ac_stats);
  649.     av_freep(&s->error_status_table);
  650.     av_freep(&s->mb_index2xy);
  651.     av_freep(&s->lambda_table);
  652.     av_freep(&s->q_intra_matrix);
  653.     av_freep(&s->q_inter_matrix);
  654.     av_freep(&s->q_intra_matrix16);
  655.     av_freep(&s->q_inter_matrix16);
  656.     av_freep(&s->input_picture);
  657.     av_freep(&s->reordered_input_picture);
  658.     av_freep(&s->dct_offset);
  660.     if(s->picture){
  661.         for(i=0; i<MAX_PICTURE_COUNT; i++){
  662.             free_picture(s, &s->picture[i]);
  663.         }
  664.     }
  665.     av_freep(&s->picture);
  666.     s->context_initialized = 0;
  667.     s->last_picture_ptr=
  668.     s->next_picture_ptr=
  669.     s->current_picture_ptr= NULL;
  670.     s->linesize= s->uvlinesize= 0;
  672.     for(i=0; i<3; i++)
  673.         av_freep(&s->visualization_buffer[i]);
  675.     avcodec_default_free_buffers(s->avctx);
  676. }
  678. void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
  679. {
  680.     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
  681.     uint8_t index_run[MAX_RUN+1];
  682.     int last, run, level, start, end, i;
  684.     /* If table is static, we can quit if rl->max_level[0] is not NULL */
  685.     if(static_store && rl->max_level[0])
  686.         return;
  688.     /* compute max_level[], max_run[] and index_run[] */
  689.     for(last=0;last<2;last++) {
  690.         if (last == 0) {
  691.             start = 0;
  692.             end = rl->last;
  693.         } else {
  694.             start = rl->last;
  695.             end = rl->n;
  696.         }
  698.         memset(max_level, 0, MAX_RUN + 1);
  699.         memset(max_run, 0, MAX_LEVEL + 1);
  700.         memset(index_run, rl->n, MAX_RUN + 1);
  701.         for(i=start;i<end;i++) {
  702.             run = rl->table_run[i];
  703.             level = rl->table_level[i];
  704.             if (index_run[run] == rl->n)
  705.                 index_run[run] = i;
  706.             if (level > max_level[run])
  707.                 max_level[run] = level;
  708.             if (run > max_run[level])
  709.                 max_run[level] = run;
  710.         }
  711.         if(static_store)
  712.             rl->max_level[last] = static_store[last];
  713.         else
  714.             rl->max_level[last] = av_malloc(MAX_RUN + 1);
  715.         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
  716.         if(static_store)
  717.             rl->max_run[last] = static_store[last] + MAX_RUN + 1;
  718.         else
  719.             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
  720.         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
  721.         if(static_store)
  722.             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
  723.         else
  724.             rl->index_run[last] = av_malloc(MAX_RUN + 1);
  725.         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
  726.     }
  727. }
  729. void init_vlc_rl(RLTable *rl)
  730. {
  731.     int i, q;
  733.     for(q=0; q<32; q++){
  734.         int qmul= q*2;
  735.         int qadd= (q-1)|1;
  737.         if(q==0){
  738.             qmul=1;
  739.             qadd=0;
  740.         }
  741.         for(i=0; i<rl->vlc.table_size; i++){
  742.             int code= rl->vlc.table[i][0];
  743.             int len = rl->vlc.table[i][1];
  744.             int level, run;
  746.             if(len==0){ // illegal code
  747.                 run= 66;
  748.                 level= MAX_LEVEL;
  749.             }else if(len<0){ //more bits needed
  750.                 run= 0;
  751.                 level= code;
  752.             }else{
  753.                 if(code==rl->n){ //esc
  754.                     run= 66;
  755.                     level= 0;
  756.                 }else{
  757.                     run=   rl->table_run  [code] + 1;
  758.                     level= rl->table_level[code] * qmul + qadd;
  759.                     if(code >= rl->last) run+=192;
  760.                 }
  761.             }
  762.             rl->rl_vlc[q][i].len= len;
  763.             rl->rl_vlc[q][i].level= level;
  764.             rl->rl_vlc[q][i].run= run;
  765.         }
  766.     }
  767. }
  769. int ff_find_unused_picture(MpegEncContext *s, int shared){
  770.     int i;
  772.     if(shared){
  773.         for(i=0; i<MAX_PICTURE_COUNT; i++){
  774.             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
  775.         }
  776.     }else{
  777.         for(i=0; i<MAX_PICTURE_COUNT; i++){
  778.             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
  779.         }
  780.         for(i=0; i<MAX_PICTURE_COUNT; i++){
  781.             if(s->picture[i].data[0]==NULL) return i;
  782.         }
  783.     }
  785.     av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflown");
  786.     /* We could return -1, but the codec would crash trying to draw into a
  787.      * non-existing frame anyway. This is safer than waiting for a random crash.
  788.      * Also the return of this is never useful, an encoder must only allocate
  789.      * as much as allowed in the specification. This has no relationship to how
  790.      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
  791.      * enough for such valid streams).
  792.      * Plus, a decoder has to check stream validity and remove frames if too
  793.      * many reference frames are around. Waiting for "OOM" is not correct at
  794.      * all. Similarly, missing reference frames have to be replaced by
  795.      * interpolated/MC frames, anything else is a bug in the codec ...
  796.      */
  797.     abort();
  798.     return -1;
  799. }
  801. static void update_noise_reduction(MpegEncContext *s){
  802.     int intra, i;
  804.     for(intra=0; intra<2; intra++){
  805.         if(s->dct_count[intra] > (1<<16)){
  806.             for(i=0; i<64; i++){
  807.                 s->dct_error_sum[intra][i] >>=1;
  808.             }
  809.             s->dct_count[intra] >>= 1;
  810.         }
  812.         for(i=0; i<64; i++){
  813.             s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
  814.         }
  815.     }
  816. }
  818. /**
  819.  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
  820.  */
  821. int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
  822. {
  823.     int i;
  824.     AVFrame *pic;
  825.     s->mb_skipped = 0;
  827.     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
  829.     /* mark&release old frames */
  830.     if (s->pict_type != FF_B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
  831.       if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
  832.         avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
  834.         /* release forgotten pictures */
  835.         /* if(mpeg124/h263) */
  836.         if(!s->encoding){
  837.             for(i=0; i<MAX_PICTURE_COUNT; i++){
  838.                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
  839.                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picturen");
  840.                     avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
  841.                 }
  842.             }
  843.         }
  844.       }
  845.     }
  846. alloc:
  847.     if(!s->encoding){
  848.         /* release non reference frames */
  849.         for(i=0; i<MAX_PICTURE_COUNT; i++){
  850.             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
  851.                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
  852.             }
  853.         }
  855.         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
  856.             pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
  857.         else{
  858.             i= ff_find_unused_picture(s, 0);
  859.             pic= (AVFrame*)&s->picture[i];
  860.         }
  862.         pic->reference= 0;
  863.         if (!s->dropable){
  864.             if (s->codec_id == CODEC_ID_H264)
  865.                 pic->reference = s->picture_structure;
  866.             else if (s->pict_type != FF_B_TYPE)
  867.                 pic->reference = 3;
  868.         }
  870.         pic->coded_picture_number= s->coded_picture_number++;
  872.         if( alloc_picture(s, (Picture*)pic, 0) < 0)
  873.             return -1;
  875.         s->current_picture_ptr= (Picture*)pic;
  876.         s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
  877.         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
  878.     }
  880.     s->current_picture_ptr->pict_type= s->pict_type;
  881. //    if(s->flags && CODEC_FLAG_QSCALE)
  882.   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
  883.     s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
  885.     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
  887.     if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3)
  888. {
  889. if (s->pict_type != FF_B_TYPE) {
  890. s->last_picture_ptr= s->next_picture_ptr;
  891. if(!s->dropable)
  892. s->next_picture_ptr= s->current_picture_ptr;
  893. }
  894. /*    av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%dn", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
  895. s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
  896. s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
  897. s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
  898. s->pict_type, s->dropable);*/
  900. if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
  901. if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
  903. if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable && s->codec_id != CODEC_ID_H264){
  904. av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframen");
  905. assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
  906. goto alloc;
  907. }
  909. assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
  911. if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
  912. int i;
  913. for(i=0; i<4; i++){
  914. if(s->picture_structure == PICT_BOTTOM_FIELD){
  915.  s->current_picture.data[i] += s->current_picture.linesize[i];
  916. }
  917. s->current_picture.linesize[i] *= 2;
  918. s->last_picture.linesize[i] *=2;
  919. s->next_picture.linesize[i] *=2;
  920. }
  921. }
  922. }
  924.     s->hurry_up= s->avctx->hurry_up;
  925.     s->error_recognition= avctx->error_recognition;
  927.     /* set dequantizer, we can't do it during init as it might change for mpeg4
  928.        and we can't do it in the header decode as init is not called for mpeg4 there yet */
  929.     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
  930.         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
  931.         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
  932.     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
  933.         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
  934.         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
  935.     }else{
  936.         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
  937.         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
  938.     }
  940.     if(s->dct_error_sum){
  941.         assert(s->avctx->noise_reduction && s->encoding);
  943.         update_noise_reduction(s);
  944.     }
  946. #ifdef CONFIG_XVMC
  947.     if(s->avctx->xvmc_acceleration)
  948.         return XVMC_field_start(s, avctx);
  949. #endif
  950.     return 0;
  951. }
  953. /* generic function for encode/decode called after a frame has been coded/decoded */
  954. void MPV_frame_end(MpegEncContext *s)
  955. {
  956.     int i;
  957.     /* draw edge for correct motion prediction if outside */
  958. #ifdef CONFIG_XVMC
  959. //just to make sure that all data is rendered.
  960.     if(s->avctx->xvmc_acceleration){
  961.         XVMC_field_end(s);
  962.     }else
  963. #endif
  964.     if(!(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
  965.        && s->unrestricted_mv
  966.        && s->current_picture.reference
  967.        && !s->intra_only
  968.        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
  969.             s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
  970.             s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
  971.             s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
  972.     }
  973.     emms_c();
  975.     s->last_pict_type    = s->pict_type;
  976.     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
  977.     if(s->pict_type!=FF_B_TYPE){
  978.         s->last_non_b_pict_type= s->pict_type;
  979.     }
  980. #if 0
  981.         /* copy back current_picture variables */
  982.     for(i=0; i<MAX_PICTURE_COUNT; i++){
  983.         if(s->picture[i].data[0] == s->current_picture.data[0]){
  984.             s->picture[i]= s->current_picture;
  985.             break;
  986.         }
  987.     }
  988.     assert(i<MAX_PICTURE_COUNT);
  989. #endif
  991.     if(s->encoding){
  992.         /* release non-reference frames */
  993.         for(i=0; i<MAX_PICTURE_COUNT; i++){
  994.             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
  995.                 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
  996.             }
  997.         }
  998.     }
  999.     // clear copies, to avoid confusion
  1000. #if 0
  1001.     memset(&s->last_picture, 0, sizeof(Picture));
  1002.     memset(&s->next_picture, 0, sizeof(Picture));
  1003.     memset(&s->current_picture, 0, sizeof(Picture));
  1004. #endif
  1005.     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
  1006. }
  1008. /**
  1009.  * draws an line from (ex, ey) -> (sx, sy).
  1010.  * @param w width of the image
  1011.  * @param h height of the image
  1012.  * @param stride stride/linesize of the image
  1013.  * @param color color of the arrow
  1014.  */
  1015. /*
  1016. static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
  1017.     int x, y, fr, f;
  1019.     sx= av_clip(sx, 0, w-1);
  1020.     sy= av_clip(sy, 0, h-1);
  1021.     ex= av_clip(ex, 0, w-1);
  1022.     ey= av_clip(ey, 0, h-1);
  1024.     buf[sy*stride + sx]+= color;
  1026.     if(FFABS(ex - sx) > FFABS(ey - sy)){
  1027.         if(sx > ex){
  1028.             FFSWAP(int, sx, ex);
  1029.             FFSWAP(int, sy, ey);
  1030.         }
  1031.         buf+= sx + sy*stride;
  1032.         ex-= sx;
  1033.         f= ((ey-sy)<<16)/ex;
  1034.         for(x= 0; x <= ex; x++){
  1035.             y = (x*f)>>16;
  1036.             fr= (x*f)&0xFFFF;
  1037.             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
  1038.             buf[(y+1)*stride + x]+= (color*         fr )>>16;
  1039.         }
  1040.     }else{
  1041.         if(sy > ey){
  1042.             FFSWAP(int, sx, ex);
  1043.             FFSWAP(int, sy, ey);
  1044.         }
  1045.         buf+= sx + sy*stride;
  1046.         ey-= sy;
  1047.         if(ey) f= ((ex-sx)<<16)/ey;
  1048.         else   f= 0;
  1049.         for(y= 0; y <= ey; y++){
  1050.             x = (y*f)>>16;
  1051.             fr= (y*f)&0xFFFF;
  1052.             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
  1053.             buf[y*stride + x+1]+= (color*         fr )>>16;
  1054.         }
  1055.     }
  1056. }
  1057. */
  1058. /**
  1059.  * draws an arrow from (ex, ey) -> (sx, sy).
  1060.  * @param w width of the image
  1061.  * @param h height of the image
  1062.  * @param stride stride/linesize of the image
  1063.  * @param color color of the arrow
  1064.  */
  1065. /*
  1066. static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
  1067.     int dx,dy;
  1069.     sx= av_clip(sx, -100, w+100);
  1070.     sy= av_clip(sy, -100, h+100);
  1071.     ex= av_clip(ex, -100, w+100);
  1072.     ey= av_clip(ey, -100, h+100);
  1074.     dx= ex - sx;
  1075.     dy= ey - sy;
  1077.     if(dx*dx + dy*dy > 3*3){
  1078.         int rx=  dx + dy;
  1079.         int ry= -dx + dy;
  1080.         int length= ff_sqrt((rx*rx + ry*ry)<<8);
  1082.         //FIXME subpixel accuracy
  1083.         rx= ROUNDED_DIV(rx*3<<4, length);
  1084.         ry= ROUNDED_DIV(ry*3<<4, length);
  1086.         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
  1087.         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
  1088.     }
  1089.     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
  1090. }
  1091. */
  1092. /**
  1093.  * prints debuging info for the given picture.
  1094.  */
  1095. /*
  1096. void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
  1098.     if(!pict || !pict->mb_type) return;
  1100.     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
  1101.         int x,y;
  1103.         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
  1104.         switch (pict->pict_type) {
  1105.             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"In"); break;
  1106.             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"Pn"); break;
  1107.             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"Bn"); break;
  1108.             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"Sn"); break;
  1109.             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SIn"); break;
  1110.             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SPn"); break;
  1111.         }
  1112.         for(y=0; y<s->mb_height; y++){
  1113.             for(x=0; x<s->mb_width; x++){
  1114.                 if(s->avctx->debug&FF_DEBUG_SKIP){
  1115.                     int count= s->mbskip_table[x + y*s->mb_stride];
  1116.                     if(count>9) count=9;
  1117.                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
  1118.                 }
  1119.                 if(s->avctx->debug&FF_DEBUG_QP){
  1120.                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
  1121.                 }
  1122.                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
  1123.                     int mb_type= pict->mb_type[x + y*s->mb_stride];
  1124.                     //Type & MV direction
  1125.                     if(IS_PCM(mb_type))
  1126.                         av_log(s->avctx, AV_LOG_DEBUG, "P");
  1127.                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
  1128.                         av_log(s->avctx, AV_LOG_DEBUG, "A");
  1129.                     else if(IS_INTRA4x4(mb_type))
  1130.                         av_log(s->avctx, AV_LOG_DEBUG, "i");
  1131.                     else if(IS_INTRA16x16(mb_type))
  1132.                         av_log(s->avctx, AV_LOG_DEBUG, "I");
  1133.                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
  1134.                         av_log(s->avctx, AV_LOG_DEBUG, "d");
  1135.                     else if(IS_DIRECT(mb_type))
  1136.                         av_log(s->avctx, AV_LOG_DEBUG, "D");
  1137.                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
  1138.                         av_log(s->avctx, AV_LOG_DEBUG, "g");
  1139.                     else if(IS_GMC(mb_type))
  1140.                         av_log(s->avctx, AV_LOG_DEBUG, "G");
  1141.                     else if(IS_SKIP(mb_type))
  1142.                         av_log(s->avctx, AV_LOG_DEBUG, "S");
  1143.                     else if(!USES_LIST(mb_type, 1))
  1144.                         av_log(s->avctx, AV_LOG_DEBUG, ">");
  1145.                     else if(!USES_LIST(mb_type, 0))
  1146.                         av_log(s->avctx, AV_LOG_DEBUG, "<");
  1147.                     else{
  1148.                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
  1149.                         av_log(s->avctx, AV_LOG_DEBUG, "X");
  1150.                     }
  1152.                     //segmentation
  1153.                     if(IS_8X8(mb_type))
  1154.                         av_log(s->avctx, AV_LOG_DEBUG, "+");
  1155.                     else if(IS_16X8(mb_type))
  1156.                         av_log(s->avctx, AV_LOG_DEBUG, "-");
  1157.                     else if(IS_8X16(mb_type))
  1158.                         av_log(s->avctx, AV_LOG_DEBUG, "|");
  1159.                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
  1160.                         av_log(s->avctx, AV_LOG_DEBUG, " ");
  1161.                     else
  1162.                         av_log(s->avctx, AV_LOG_DEBUG, "?");
  1165.                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
  1166.                         av_log(s->avctx, AV_LOG_DEBUG, "=");
  1167.                     else
  1168.                         av_log(s->avctx, AV_LOG_DEBUG, " ");
  1169.                 }
  1170. //                av_log(s->avctx, AV_LOG_DEBUG, " ");
  1171.             }
  1172.             av_log(s->avctx, AV_LOG_DEBUG, "n");
  1173.         }
  1174.     }
  1176.     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
  1177.         const int shift= 1 + s->quarter_sample;
  1178.         int mb_y;
  1179.         uint8_t *ptr;
  1180.         int i;
  1181.         int h_chroma_shift, v_chroma_shift, block_height;
  1182.         const int width = s->avctx->width;
  1183.         const int height= s->avctx->height;
  1184.         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
  1185.         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
  1186.         s->low_delay=0; //needed to see the vectors without trashing the buffers
  1188.         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
  1189.         for(i=0; i<3; i++){
  1190.             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
  1191.             pict->data[i]= s->visualization_buffer[i];
  1192.         }
  1193.         pict->type= FF_BUFFER_TYPE_COPY;
  1194.         ptr= pict->data[0];
  1195.         block_height = 16>>v_chroma_shift;
  1197.         for(mb_y=0; mb_y<s->mb_height; mb_y++){
  1198.             int mb_x;
  1199.             for(mb_x=0; mb_x<s->mb_width; mb_x++){
  1200.                 const int mb_index= mb_x + mb_y*s->mb_stride;
  1201.                 if((s->avctx->debug_mv) && pict->motion_val){
  1202.                   int type;
  1203.                   for(type=0; type<3; type++){
  1204.                     int direction = 0;
  1205.                     switch (type) {
  1206.                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
  1207.                                 continue;
  1208.                               direction = 0;
  1209.                               break;
  1210.                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
  1211.                                 continue;
  1212.                               direction = 0;
  1213.                               break;
  1214.                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
  1215.                                 continue;
  1216.                               direction = 1;
  1217.                               break;
  1218.                     }
  1219.                     if(!USES_LIST(pict->mb_type[mb_index], direction))
  1220.                         continue;
  1222.                     if(IS_8X8(pict->mb_type[mb_index])){
  1223.                       int i;
  1224.                       for(i=0; i<4; i++){
  1225.                         int sx= mb_x*16 + 4 + 8*(i&1);
  1226.                         int sy= mb_y*16 + 4 + 8*(i>>1);
  1227.                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
  1228.                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
  1229.                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
  1230.                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
  1231.                       }
  1232.                     }else if(IS_16X8(pict->mb_type[mb_index])){
  1233.                       int i;
  1234.                       for(i=0; i<2; i++){
  1235.                         int sx=mb_x*16 + 8;
  1236.                         int sy=mb_y*16 + 4 + 8*i;
  1237.                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
  1238.                         int mx=(pict->motion_val[direction][xy][0]>>shift);
  1239.                         int my=(pict->motion_val[direction][xy][1]>>shift);
  1241.                         if(IS_INTERLACED(pict->mb_type[mb_index]))
  1242.                             my*=2;
  1244.                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
  1245.                       }
  1246.                     }else if(IS_8X16(pict->mb_type[mb_index])){
  1247.                       int i;
  1248.                       for(i=0; i<2; i++){
  1249.                         int sx=mb_x*16 + 4 + 8*i;
  1250.                         int sy=mb_y*16 + 8;
  1251.                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
  1252.                         int mx=(pict->motion_val[direction][xy][0]>>shift);
  1253.                         int my=(pict->motion_val[direction][xy][1]>>shift);
  1255.                         if(IS_INTERLACED(pict->mb_type[mb_index]))
  1256.                             my*=2;
  1258.                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
  1259.                       }
  1260.                     }else{
  1261.                       int sx= mb_x*16 + 8;
  1262.                       int sy= mb_y*16 + 8;
  1263.                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
  1264.                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
  1265.                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
  1266.                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
  1267.                     }
  1268.                   }
  1269.                 }
  1270.                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
  1271.                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
  1272.                     int y;
  1273.                     for(y=0; y<block_height; y++){
  1274.                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
  1275.                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
  1276.                     }
  1277.                 }
  1278.                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
  1279.                     int mb_type= pict->mb_type[mb_index];
  1280.                     uint64_t u,v;
  1281.                     int y;
  1282. #define COLOR(theta, r)
  1283. u= (int)(128 + r*cos(theta*3.141592/180));
  1284. v= (int)(128 + r*sin(theta*3.141592/180));
  1287.                     u=v=128;
  1288.                     if(IS_PCM(mb_type)){
  1289.                         COLOR(120,48)
  1290.                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
  1291.                         COLOR(30,48)
  1292.                     }else if(IS_INTRA4x4(mb_type)){
  1293.                         COLOR(90,48)
  1294.                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
  1295. //                        COLOR(120,48)
  1296.                     }else if(IS_DIRECT(mb_type)){
  1297.                         COLOR(150,48)
  1298.                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
  1299.                         COLOR(170,48)
  1300.                     }else if(IS_GMC(mb_type)){
  1301.                         COLOR(190,48)
  1302.                     }else if(IS_SKIP(mb_type)){
  1303. //                        COLOR(180,48)
  1304.                     }else if(!USES_LIST(mb_type, 1)){
  1305.                         COLOR(240,48)
  1306.                     }else if(!USES_LIST(mb_type, 0)){
  1307.                         COLOR(0,48)
  1308.                     }else{
  1309.                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
  1310.                         COLOR(300,48)
  1311.                     }
  1313.                     u*= 0x0101010101010101ULL;
  1314.                     v*= 0x0101010101010101ULL;
  1315.                     for(y=0; y<block_height; y++){
  1316.                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
  1317.                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
  1318.                     }
  1320.                     //segmentation
  1321.                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
  1322.                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
  1323.                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
  1324.                     }
  1325.                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
  1326.                         for(y=0; y<16; y++)
  1327.                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
  1328.                     }
  1329.                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
  1330.                         int dm= 1 << (mv_sample_log2-2);
  1331.                         for(i=0; i<4; i++){
  1332.                             int sx= mb_x*16 + 8*(i&1);
  1333.                             int sy= mb_y*16 + 8*(i>>1);
  1334.                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
  1335.                             //FIXME bidir
  1336.                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
  1337.                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
  1338.                                 for(y=0; y<8; y++)
  1339.                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
  1340.                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
  1341.                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
  1342.                         }
  1343.                     }
  1345.                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
  1346.                         // hmm
  1347.                     }
  1348.                 }
  1349.                 s->mbskip_table[mb_index]=0;
  1350.             }
  1351.         }
  1352.     }
  1353. }*/
  1355. static inline int hpel_motion_lowres(MpegEncContext *s,
  1356.                                   uint8_t *dest, uint8_t *src,
  1357.                                   int field_based, int field_select,
  1358.                                   int src_x, int src_y,
  1359.                                   int width, int height, int stride,
  1360.                                   int h_edge_pos, int v_edge_pos,
  1361.                                   int w, int h, h264_chroma_mc_func *pix_op,
  1362.                                   int motion_x, int motion_y)
  1363. {
  1364.     const int lowres= s->avctx->lowres;
  1365.     const int s_mask= (2<<lowres)-1;
  1366.     int emu=0;
  1367.     int sx, sy;
  1369.     if(s->quarter_sample){
  1370.         motion_x/=2;
  1371.         motion_y/=2;
  1372.     }
  1374.     sx= motion_x & s_mask;
  1375.     sy= motion_y & s_mask;
  1376.     src_x += motion_x >> (lowres+1);
  1377.     src_y += motion_y >> (lowres+1);
  1379.     src += src_y * stride + src_x;
  1381.     if(   src_x > h_edge_pos                 - (!!sx) - w
  1382.        || src_y >(v_edge_pos >> field_based) - (!!sy) - h){
  1383.         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
  1384.                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
  1385.         src= s->edge_emu_buffer;
  1386.         emu=1;
  1387.     }
  1389.     sx <<= 2 - lowres;
  1390.     sy <<= 2 - lowres;
  1391.     if(field_select)
  1392.         src += s->linesize;
  1393.     pix_op[lowres](dest, src, stride, h, sx, sy);
  1394.     return emu;
  1395. }
  1397. /* apply one mpeg motion vector to the three components */
  1398. static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
  1399.                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  1400.                                int field_based, int bottom_field, int field_select,
  1401.                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
  1402.                                int motion_x, int motion_y, int h)
  1403. {
  1404.     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
  1405.     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
  1406.     const int lowres= s->avctx->lowres;
  1407.     const int block_s= 8>>lowres;
  1408.     const int s_mask= (2<<lowres)-1;
  1409.     const int h_edge_pos = s->h_edge_pos >> lowres;
  1410.     const int v_edge_pos = s->v_edge_pos >> lowres;
  1411.     linesize   = s->current_picture.linesize[0] << field_based;
  1412.     uvlinesize = s->current_picture.linesize[1] << field_based;
  1414.     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
  1415.         motion_x/=2;
  1416.         motion_y/=2;
  1417.     }
  1419.     if(field_based){
  1420.         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
  1421.     }
  1423.     sx= motion_x & s_mask;
  1424.     sy= motion_y & s_mask;
  1425.     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
  1426.     src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
  1428.     if (s->out_format == FMT_H263) {
  1429.         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
  1430.         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
  1431.         uvsrc_x = src_x>>1;
  1432.         uvsrc_y = src_y>>1;
  1433.     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
  1434.         mx = motion_x / 4;
  1435.         my = motion_y / 4;
  1436.         uvsx = (2*mx) & s_mask;
  1437.         uvsy = (2*my) & s_mask;
  1438.         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
  1439.         uvsrc_y = s->mb_y*block_s               + (my >> lowres);
  1440.     } else {
  1441.         mx = motion_x / 2;
  1442.         my = motion_y / 2;
  1443.         uvsx = mx & s_mask;
  1444.         uvsy = my & s_mask;
  1445.         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
  1446.         uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
  1447.     }
  1449.     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
  1450.     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
  1451.     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
  1453.     if(   src_x > h_edge_pos                 - (!!sx) - 2*block_s
  1454.        || src_y >(v_edge_pos >> field_based) - (!!sy) - h){
  1455.             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
  1456.                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
  1457.             ptr_y = s->edge_emu_buffer;
  1458.             if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
  1459.                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
  1460.                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
  1461.                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
  1462.                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
  1463.                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
  1464.                 ptr_cb= uvbuf;
  1465.                 ptr_cr= uvbuf+16;
  1466.             }
  1467.     }
  1469.     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
  1470.         dest_y += s->linesize;
  1471.         dest_cb+= s->uvlinesize;
  1472.         dest_cr+= s->uvlinesize;
  1473.     }
  1475.     if(field_select){
  1476.         ptr_y += s->linesize;
  1477.         ptr_cb+= s->uvlinesize;
  1478.         ptr_cr+= s->uvlinesize;
  1479.     }
  1481.     sx <<= 2 - lowres;
  1482.     sy <<= 2 - lowres;
  1483.     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
  1485.     if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
  1486.         uvsx <<= 2 - lowres;
  1487.         uvsy <<= 2 - lowres;
  1488.         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
  1489.         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
  1490.     }
  1491.     //FIXME h261 lowres loop filter
  1492. }
  1494. static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
  1495.                                      uint8_t *dest_cb, uint8_t *dest_cr,
  1496.                                      uint8_t **ref_picture,
  1497.                                      h264_chroma_mc_func *pix_op,
  1498.                                      int mx, int my){
  1499.     const int lowres= s->avctx->lowres;
  1500.     const int block_s= 8>>lowres;
  1501.     const int s_mask= (2<<lowres)-1;
  1502.     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
  1503.     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
  1504.     int emu=0, src_x, src_y, offset, sx, sy;
  1505.     uint8_t *ptr;
  1507.     if(s->quarter_sample){
  1508.         mx/=2;
  1509.         my/=2;
  1510.     }
  1512.     /* In case of 8X8, we construct a single chroma motion vector
  1513.        with a special rounding */
  1514.     mx= ff_h263_round_chroma(mx);
  1515.     my= ff_h263_round_chroma(my);
  1517.     sx= mx & s_mask;
  1518.     sy= my & s_mask;
  1519.     src_x = s->mb_x*block_s + (mx >> (lowres+1));
  1520.     src_y = s->mb_y*block_s + (my >> (lowres+1));
  1522.     offset = src_y * s->uvlinesize + src_x;
  1523.     ptr = ref_picture[1] + offset;
  1524.     if(s->flags&CODEC_FLAG_EMU_EDGE){
  1525.         if(   src_x > h_edge_pos - (!!sx) - block_s
  1526.            || src_y > v_edge_pos - (!!sy) - block_s){
  1527.             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
  1528.             ptr= s->edge_emu_buffer;
  1529.             emu=1;
  1530.         }
  1531.     }
  1532.     sx <<= 2 - lowres;
  1533.     sy <<= 2 - lowres;
  1534.     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
  1536.     ptr = ref_picture[2] + offset;
  1537.     if(emu){
  1538.         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
  1539.         ptr= s->edge_emu_buffer;
  1540.     }
  1541.     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
  1542. }
  1544. /**
  1545.  * motion compensation of a single macroblock
  1546.  * @param s context
  1547.  * @param dest_y luma destination pointer
  1548.  * @param dest_cb chroma cb/u destination pointer
  1549.  * @param dest_cr chroma cr/v destination pointer
  1550.  * @param dir direction (0->forward, 1->backward)
  1551.  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
  1552.  * @param pic_op halfpel motion compensation function (average or put normally)
  1553.  * the motion vectors are taken from s->mv and the MV type from s->mv_type
  1554.  */
  1555. static inline void MPV_motion_lowres(MpegEncContext *s,
  1556.                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
  1557.                               int dir, uint8_t **ref_picture,
  1558.                               h264_chroma_mc_func *pix_op)
  1559. {
  1560.     int mx, my;
  1561.     int mb_x, mb_y, i;
  1562.     const int lowres= s->avctx->lowres;
  1563.     const int block_s= 8>>lowres;
  1565.     mb_x = s->mb_x;
  1566.     mb_y = s->mb_y;
  1568.     switch(s->mv_type) {
  1569.     case MV_TYPE_16X16:
  1570.         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
  1571.                     0, 0, 0,
  1572.                     ref_picture, pix_op,
  1573.                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
  1574.         break;
  1575.     case MV_TYPE_8X8:
  1576.         mx = 0;
  1577.         my = 0;
  1578.             for(i=0;i<4;i++) {
  1579.                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
  1580.                             ref_picture[0], 0, 0,
  1581.                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
  1582.                             s->width, s->height, s->linesize,
  1583.                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
  1584.                             block_s, block_s, pix_op,
  1585.                             s->mv[dir][i][0], s->mv[dir][i][1]);
  1587.                 mx += s->mv[dir][i][0];
  1588.                 my += s->mv[dir][i][1];
  1589.             }
  1591.         if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
  1592.             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
  1593.         break;
  1594.     case MV_TYPE_FIELD:
  1595.         if (s->picture_structure == PICT_FRAME) {
  1596.             /* top field */
  1597.             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
  1598.                         1, 0, s->field_select[dir][0],
  1599.                         ref_picture, pix_op,
  1600.                         s->mv[dir][0][0], s->mv[dir][0][1], block_s);
  1601.             /* bottom field */
  1602.             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
  1603.                         1, 1, s->field_select[dir][1],
  1604.                         ref_picture, pix_op,
  1605.                         s->mv[dir][1][0], s->mv[dir][1][1], block_s);
  1606.         } else {
  1607.             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
  1608.                 ref_picture= s->current_picture_ptr->data;
  1609.             }
  1611.             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
  1612.                         0, 0, s->field_select[dir][0],
  1613.                         ref_picture, pix_op,
  1614.                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
  1615.         }
  1616.         break;
  1617.     case MV_TYPE_16X8:
  1618.         for(i=0; i<2; i++){
  1619.             uint8_t ** ref2picture;
  1621.             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
  1622.                 ref2picture= ref_picture;
  1623.             }else{
  1624.                 ref2picture= s->current_picture_ptr->data;
  1625.             }
  1627.             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
  1628.                         0, 0, s->field_select[dir][i],
  1629.                         ref2picture, pix_op,
  1630.                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
  1632.             dest_y += 2*block_s*s->linesize;
  1633.             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
  1634.             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
  1635.         }
  1636.         break;
  1637.     case MV_TYPE_DMV:
  1638.         if(s->picture_structure == PICT_FRAME){
  1639.             for(i=0; i<2; i++){
  1640.                 int j;
  1641.                 for(j=0; j<2; j++){
  1642.                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
  1643.                                 1, j, j^i,
  1644.                                 ref_picture, pix_op,
  1645.                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
  1646.                 }
  1647.                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
  1648.             }
  1649.         }else{
  1650.             for(i=0; i<2; i++){
  1651.                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
  1652.                             0, 0, s->picture_structure != i+1,
  1653.                             ref_picture, pix_op,
  1654.                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
  1656.                 // after put we make avg of the same block
  1657.                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
  1659.                 //opposite parity is always in the same frame if this is second field
  1660.                 if(!s->first_field){
  1661.                     ref_picture = s->current_picture_ptr->data;
  1662.                 }
  1663.             }
  1664.         }
  1665.     break;
  1666.     default: assert(0);
  1667.     }
  1668. }
  1670. /* put block[] to dest[] */
  1671. static inline void put_dct(MpegEncContext *s,
  1672.                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
  1673. {
  1674.     s->dct_unquantize_intra(s, block, i, qscale);
  1675.     s->dsp.idct_put (dest, line_size, block);
  1676. }
  1678. /* add block[] to dest[] */
  1679. static inline void add_dct(MpegEncContext *s,
  1680.                            DCTELEM *block, int i, uint8_t *dest, int line_size)
  1681. {
  1682.     if (s->block_last_index[i] >= 0) {
  1683.         s->dsp.idct_add (dest, line_size, block);
  1684.     }
  1685. }
  1686. /*
  1687. static inline void add_dequant_dct(MpegEncContext *s,
  1688.                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
  1689. {
  1690.     if (s->block_last_index[i] >= 0) {
  1691.         s->dct_unquantize_inter(s, block, i, qscale);
  1693.         s->dsp.idct_add (dest, line_size, block);
  1694.     }
  1695. }
  1696. */
  1697. /**
  1698.  * cleans dc, ac, coded_block for the current non intra MB
  1699.  */
  1700. void ff_clean_intra_table_entries(MpegEncContext *s)
  1701. {
  1702.     int wrap = s->b8_stride;
  1703.     int xy = s->block_index[0];
  1705.     s->dc_val[0][xy           ] =
  1706.     s->dc_val[0][xy + 1       ] =
  1707.     s->dc_val[0][xy     + wrap] =
  1708.     s->dc_val[0][xy + 1 + wrap] = 1024;
  1709.     /* ac pred */
  1710.     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
  1711.     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
  1712.     if (s->msmpeg4_version>=3) {
  1713.         s->coded_block[xy           ] =
  1714.         s->coded_block[xy + 1       ] =
  1715.         s->coded_block[xy     + wrap] =
  1716.         s->coded_block[xy + 1 + wrap] = 0;
  1717.     }
  1718.     /* chroma */
  1719.     wrap = s->mb_stride;
  1720.     xy = s->mb_x + s->mb_y * wrap;
  1721.     s->dc_val[1][xy] =
  1722.     s->dc_val[2][xy] = 1024;
  1723.     /* ac pred */
  1724.     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
  1725.     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
  1727.     s->mbintra_table[xy]= 0;
  1728. }
  1730. /* generic function called after a macroblock has been parsed by the
  1731.    decoder or after it has been encoded by the encoder.
  1733.    Important variables used:
  1734.    s->mb_intra : true if intra macroblock
  1735.    s->mv_dir   : motion vector direction
  1736.    s->mv_type  : motion vector type
  1737.    s->mv       : motion vector
  1738.    s->interlaced_dct : true if interlaced dct used (mpeg2)
  1739.  */
  1740. static av_always_inline
  1741. void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
  1742.                             int lowres_flag, int is_mpeg12)
  1743. {
  1744.     int mb_x, mb_y;
  1745.     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
  1746. #ifdef CONFIG_XVMC
  1747.     if(s->avctx->xvmc_acceleration){
  1748.         XVMC_decode_mb(s);//xvmc uses pblocks
  1749.         return;
  1750.     }
  1751. #endif
  1753.     mb_x = s->mb_x;
  1754.     mb_y = s->mb_y;
  1756.     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
  1757.        /* save DCT coefficients */
  1758.        int i,j;
  1759.        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
  1760.        for(i=0; i<6; i++)
  1761.            for(j=0; j<64; j++)
  1762.                *dct++ = block[i][s->dsp.idct_permutation[j]];
  1763.     }
  1765.     s->current_picture.qscale_table[mb_xy]= s->qscale;
  1767.     /* update DC predictors for P macroblocks */
  1768.     if (!s->mb_intra) {
  1769.         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
  1770.             if(s->mbintra_table[mb_xy])
  1771.                 ff_clean_intra_table_entries(s);
  1772.         } else {
  1773.             s->last_dc[0] =
  1774.             s->last_dc[1] =
  1775.             s->last_dc[2] = 128 << s->intra_dc_precision;
  1776.         }
  1777.     }
  1778.     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
  1779.         s->mbintra_table[mb_xy]=1;
  1781.     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
  1782.         uint8_t *dest_y, *dest_cb, *dest_cr;
  1783.         int dct_linesize, dct_offset;
  1784.         op_pixels_func (*op_pix)[4];
  1785.         qpel_mc_func (*op_qpix)[16];
  1786.         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
  1787.         const int uvlinesize= s->current_picture.linesize[1];
  1788.         const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
  1789.         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
  1791.         /* avoid copy if macroblock skipped in last frame too */
  1792.         /* skip only during decoding as we might trash the buffers during encoding a bit */
  1793.         if(!s->encoding){
  1794.             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
  1795.             const int age= s->current_picture.age;
  1797.             assert(age);
  1799.             if (s->mb_skipped) {
  1800.                 s->mb_skipped= 0;
  1801.                 assert(s->pict_type!=FF_I_TYPE);
  1803.                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
  1804.                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
  1806.                 /* if previous was skipped too, then nothing to do !  */
  1807.                 if (*mbskip_ptr >= age && s->current_picture.reference){
  1808.                     return;
  1809.                 }
  1810.             } else if(!s->current_picture.reference){
  1811.                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
  1812.                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
  1813.             } else{
  1814.                 *mbskip_ptr = 0; /* not skipped */
  1815.             }
  1816.         }
  1818.         dct_linesize = linesize << s->interlaced_dct;
  1819.         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
  1821.         if(readable){
  1822.             dest_y=  s->dest[0];
  1823.             dest_cb= s->dest[1];
  1824.             dest_cr= s->dest[2];
  1825.         }else{
  1826.             dest_y = s->b_scratchpad;
  1827.             dest_cb= s->b_scratchpad+16*linesize;
  1828.             dest_cr= s->b_scratchpad+32*linesize;
  1829.         }
  1831.         if (!s->mb_intra) 
  1832. {
  1833.             /* motion handling */
  1834.             /* decoding or more than one mb_type (MC was already done otherwise) */
  1835.             if(!s->encoding)
  1836. {
  1837.                 if(lowres_flag)
  1838. {
  1839.                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
  1841.                     if (s->mv_dir & MV_DIR_FORWARD) {
  1842.                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
  1843.                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
  1844.                     }
  1845.                     if (s->mv_dir & MV_DIR_BACKWARD) {
  1846.                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
  1847.                     }
  1848.                 }
  1849. else
  1850. {
  1851.                     op_qpix= s->me.qpel_put;
  1852.                     if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
  1853.                         op_pix = s->dsp.put_pixels_tab;
  1854.                     }else{
  1855.                         op_pix = s->dsp.put_no_rnd_pixels_tab;
  1856.                     }
  1857.                     if (s->mv_dir & MV_DIR_FORWARD) {
  1858.                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
  1859.                         op_pix = s->dsp.avg_pixels_tab;
  1860.                         op_qpix= s->me.qpel_avg;
  1861.                     }
  1862.                     if (s->mv_dir & MV_DIR_BACKWARD) {
  1863.                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
  1864.                     }
  1865.                 }
  1866.             }
  1868.             /* skip dequant / idct if we are really late ;) */
  1869.             if(s->hurry_up>1) goto skip_idct;
  1870.             if(s->avctx->skip_idct){
  1871.                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
  1872.                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
  1873.                    || s->avctx->skip_idct >= AVDISCARD_ALL)
  1874.                     goto skip_idct;
  1875.             }
  1877.             /* add dct residue */
  1878.             /*if(s->encoding 
  1879. || 
  1880. !(   s->h263_msmpeg4 
  1881. || 
  1882. s->codec_id==CODEC_ID_MPEG1VIDEO 
  1883. || 
  1884. s->codec_id==CODEC_ID_MPEG2VIDEO
  1885.                         || 
  1886. (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant)))
  1887. {
  1888.                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
  1889.                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
  1890.                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
  1891.                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
  1893.                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
  1894.                     if (s->chroma_y_shift){
  1895.                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
  1896.                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
  1897.                     }else{
  1898.                         dct_linesize >>= 1;
  1899.                         dct_offset >>=1;
  1900.                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
  1901.                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
  1902.                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
  1903.                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
  1904.                     }
  1905.                 }
  1906.             } 
  1907. else*/ if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2))
  1908. {
  1909.                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
  1910.                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
  1911.                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
  1912.                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
  1914.                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
  1915. {
  1916.                     if(s->chroma_y_shift)
  1917. {//Chroma420
  1918.                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
  1919.                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
  1920.                     }
  1921. else
  1922. {
  1923.                         //chroma422
  1924.                         dct_linesize = uvlinesize << s->interlaced_dct;
  1925.                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
  1927.                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
  1928.                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
  1929.                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
  1930.                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
  1931.                         if(!s->chroma_x_shift){//Chroma444
  1932.                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
  1933.                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
  1934.                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
  1935.                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
  1936.                         }
  1937.                     }
  1938.                 }//fi gray
  1939.             }
  1940.             /*else if (ENABLE_WMV2) 
  1941. {
  1942.                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
  1943.             }*/
  1944.         } 
  1945. else 
  1946. {
  1947.             /* dct only in intra block */
  1948.             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
  1949.                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
  1950.                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
  1951.                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
  1952.                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
  1954.                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
  1955.                     if(s->chroma_y_shift){
  1956.                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
  1957.                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
  1958.                     }else{
  1959.                         dct_offset >>=1;
  1960.                         dct_linesize >>=1;
  1961.                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
  1962.                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
  1963.                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
  1964.                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
  1965.                     }
  1966.                 }
  1967.             }else{
  1968.                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
  1969.                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
  1970.                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
  1971.                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
  1973.                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
  1974.                     if(s->chroma_y_shift){
  1975.                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
  1976.                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
  1977.                     }else{
  1979.                         dct_linesize = uvlinesize << s->interlaced_dct;
  1980.                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
  1982.                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
  1983.                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
  1984.                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
  1985.                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
  1986.                         if(!s->chroma_x_shift){//Chroma444
  1987.                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
  1988.                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
  1989.                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
  1990.                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
  1991.                         }
  1992.                     }
  1993.                 }//gray
  1994.             }
  1995.         }
  1996. skip_idct:
  1997.         if(!readable){
  1998.             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
  1999.             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
  2000.             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
  2001.         }
  2002.     }
  2003. }
  2005. void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
  2006. #ifndef CONFIG_SMALL
  2007.     if(s->out_format == FMT_MPEG1) {
  2008.         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
  2009.         else                 MPV_decode_mb_internal(s, block, 0, 1);
  2010.     } else
  2011. #endif
  2012.     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
  2013.     else                  MPV_decode_mb_internal(s, block, 0, 0);
  2014. }
  2016. /**
  2017.  *
  2018.  * @param h is the normal height, this will be reduced automatically if needed for the last row
  2019.  */
  2020. void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
  2021.     if (s->avctx->draw_horiz_band) {
  2022.         AVFrame *src;
  2023.         int offset[4];
  2025.         if(s->picture_structure != PICT_FRAME){
  2026.             h <<= 1;
  2027.             y <<= 1;
  2028.             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
  2029.         }
  2031.         h= FFMIN(h, s->avctx->height - y);
  2033.         if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
  2034.             src= (AVFrame*)s->current_picture_ptr;
  2035.         else if(s->last_picture_ptr)
  2036.             src= (AVFrame*)s->last_picture_ptr;
  2037.         else
  2038.             return;
  2040.         if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
  2041.             offset[0]=
  2042.             offset[1]=
  2043.             offset[2]=
  2044.             offset[3]= 0;
  2045.         }else{
  2046.             offset[0]= y * s->linesize;
  2047.             offset[1]=
  2048.             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
  2049.             offset[3]= 0;
  2050.         }
  2052.         emms_c();
  2054.         s->avctx->draw_horiz_band(s->avctx, src, offset,
  2055.                                   y, s->picture_structure, h);
  2056.     }
  2057. }
  2059. void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
  2060.     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
  2061.     const int uvlinesize= s->current_picture.linesize[1];
  2062.     const int mb_size= 4 - s->avctx->lowres;
  2064.     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
  2065.     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
  2066.     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
  2067.     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
  2068.     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
  2069.     s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
  2070.     //block_index is not used by mpeg2, so it is not affected by chroma_format
  2072.     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
  2073.     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
  2074.     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
  2076.     if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
  2077.     {
  2078.         s->dest[0] += s->mb_y *   linesize << mb_size;
  2079.         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
  2080.         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
  2081.     }
  2082. }
  2084. void ff_mpeg_flush(AVCodecContext *avctx){
  2085.     int i;
  2086.     MpegEncContext *s = avctx->priv_data;
  2088.     if(s==NULL || s->picture==NULL)
  2089.         return;
  2091.     for(i=0; i<MAX_PICTURE_COUNT; i++){
  2092.        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
  2093.                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
  2094.         avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
  2095.     }
  2096.     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
  2098.     s->mb_x= s->mb_y= 0;
  2100.     s->parse_context.state= -1;
  2101.     s->parse_context.frame_start_found= 0;
  2102.     s->parse_context.overread= 0;
  2103.     s->parse_context.overread_index= 0;
  2104.     s->parse_context.index= 0;
  2105.     s->parse_context.last_index= 0;
  2106.     s->bitstream_buffer_size=0;
  2107.     s->pp_time=0;
  2108. }
  2110. static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
  2111.                                    DCTELEM *block, int n, int qscale)
  2112. {
  2113.     int i, level, nCoeffs;
  2114.     const uint16_t *quant_matrix;
  2116.     nCoeffs= s->block_last_index[n];
  2118.     if (n < 4)
  2119.         block[0] = block[0] * s->y_dc_scale;
  2120.     else
  2121.         block[0] = block[0] * s->c_dc_scale;
  2122.     /* XXX: only mpeg1 */
  2123.     quant_matrix = s->intra_matrix;
  2124.     for(i=1;i<=nCoeffs;i++) {
  2125.         int j= s->intra_scantable.permutated[i];
  2126.         level = block[j];
  2127.         if (level) {
  2128.             if (level < 0) {
  2129.                 level = -level;
  2130.                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2131.                 level = (level - 1) | 1;
  2132.                 level = -level;
  2133.             } else {
  2134.                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2135.                 level = (level - 1) | 1;
  2136.             }
  2137.             block[j] = level;
  2138.         }
  2139.     }
  2140. }
  2142. static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
  2143.                                    DCTELEM *block, int n, int qscale)
  2144. {
  2145.     int i, level, nCoeffs;
  2146.     const uint16_t *quant_matrix;
  2148.     nCoeffs= s->block_last_index[n];
  2150.     quant_matrix = s->inter_matrix;
  2151.     for(i=0; i<=nCoeffs; i++) {
  2152.         int j= s->intra_scantable.permutated[i];
  2153.         level = block[j];
  2154.         if (level) {
  2155.             if (level < 0) {
  2156.                 level = -level;
  2157.                 level = (((level << 1) + 1) * qscale *
  2158.                          ((int) (quant_matrix[j]))) >> 4;
  2159.                 level = (level - 1) | 1;
  2160.                 level = -level;
  2161.             } else {
  2162.                 level = (((level << 1) + 1) * qscale *
  2163.                          ((int) (quant_matrix[j]))) >> 4;
  2164.                 level = (level - 1) | 1;
  2165.             }
  2166.             block[j] = level;
  2167.         }
  2168.     }
  2169. }
  2171. static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
  2172.                                    DCTELEM *block, int n, int qscale)
  2173. {
  2174.     int i, level, nCoeffs;
  2175.     const uint16_t *quant_matrix;
  2177.     if(s->alternate_scan) nCoeffs= 63;
  2178.     else nCoeffs= s->block_last_index[n];
  2180.     if (n < 4)
  2181.         block[0] = block[0] * s->y_dc_scale;
  2182.     else
  2183.         block[0] = block[0] * s->c_dc_scale;
  2184.     quant_matrix = s->intra_matrix;
  2185.     for(i=1;i<=nCoeffs;i++) {
  2186.         int j= s->intra_scantable.permutated[i];
  2187.         level = block[j];
  2188.         if (level) {
  2189.             if (level < 0) {
  2190.                 level = -level;
  2191.                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2192.                 level = -level;
  2193.             } else {
  2194.                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2195.             }
  2196.             block[j] = level;
  2197.         }
  2198.     }
  2199. }
  2201. static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
  2202.                                    DCTELEM *block, int n, int qscale)
  2203. {
  2204.     int i, level, nCoeffs;
  2205.     const uint16_t *quant_matrix;
  2206.     int sum=-1;
  2208.     if(s->alternate_scan) nCoeffs= 63;
  2209.     else nCoeffs= s->block_last_index[n];
  2211.     if (n < 4)
  2212.         block[0] = block[0] * s->y_dc_scale;
  2213.     else
  2214.         block[0] = block[0] * s->c_dc_scale;
  2215.     quant_matrix = s->intra_matrix;
  2216.     for(i=1;i<=nCoeffs;i++) {
  2217.         int j= s->intra_scantable.permutated[i];
  2218.         level = block[j];
  2219.         if (level) {
  2220.             if (level < 0) {
  2221.                 level = -level;
  2222.                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2223.                 level = -level;
  2224.             } else {
  2225.                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
  2226.             }
  2227.             block[j] = level;
  2228.             sum+=level;
  2229.         }
  2230.     }
  2231.     block[63]^=sum&1;
  2232. }
  2234. static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
  2235.                                    DCTELEM *block, int n, int qscale)
  2236. {
  2237.     int i, level, nCoeffs;
  2238.     const uint16_t *quant_matrix;
  2239.     int sum=-1;
  2241.     if(s->alternate_scan) nCoeffs= 63;
  2242.     else nCoeffs= s->block_last_index[n];
  2244.     quant_matrix = s->inter_matrix;
  2245.     for(i=0; i<=nCoeffs; i++) {
  2246.         int j= s->intra_scantable.permutated[i];
  2247.         level = block[j];
  2248.         if (level) {
  2249.             if (level < 0) {
  2250.                 level = -level;
  2251.                 level = (((level << 1) + 1) * qscale *
  2252.                          ((int) (quant_matrix[j]))) >> 4;
  2253.                 level = -level;
  2254.             } else {
  2255.                 level = (((level << 1) + 1) * qscale *
  2256.                          ((int) (quant_matrix[j]))) >> 4;
  2257.             }
  2258.             block[j] = level;
  2259.             sum+=level;
  2260.         }
  2261.     }
  2262.     block[63]^=sum&1;
  2263. }
  2265. static void dct_unquantize_h263_intra_c(MpegEncContext *s,
  2266.                                   DCTELEM *block, int n, int qscale)
  2267. {
  2268.     int i, level, qmul, qadd;
  2269.     int nCoeffs;
  2271.     assert(s->block_last_index[n]>=0);
  2273.     qmul = qscale << 1;
  2275.     if (!s->h263_aic) {
  2276.         if (n < 4)
  2277.             block[0] = block[0] * s->y_dc_scale;
  2278.         else
  2279.             block[0] = block[0] * s->c_dc_scale;
  2280.         qadd = (qscale - 1) | 1;
  2281.     }else{
  2282.         qadd = 0;
  2283.     }
  2284.     if(s->ac_pred)
  2285.         nCoeffs=63;
  2286.     else
  2287.         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
  2289.     for(i=1; i<=nCoeffs; i++) {
  2290.         level = block[i];
  2291.         if (level) {
  2292.             if (level < 0) {
  2293.                 level = level * qmul - qadd;
  2294.             } else {
  2295.                 level = level * qmul + qadd;
  2296.             }
  2297.             block[i] = level;
  2298.         }
  2299.     }
  2300. }
  2302. static void dct_unquantize_h263_inter_c(MpegEncContext *s,
  2303.                                   DCTELEM *block, int n, int qscale)
  2304. {
  2305.     int i, level, qmul, qadd;
  2306.     int nCoeffs;
  2308.     assert(s->block_last_index[n]>=0);
  2310.     qadd = (qscale - 1) | 1;
  2311.     qmul = qscale << 1;
  2313.     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
  2315.     for(i=0; i<=nCoeffs; i++) {
  2316.         level = block[i];
  2317.         if (level) {
  2318.             if (level < 0) {
  2319.                 level = level * qmul - qadd;
  2320.             } else {
  2321.                 level = level * qmul + qadd;
  2322.             }
  2323.             block[i] = level;
  2324.         }
  2325.     }
  2326. }
  2328. /**
  2329.  * set qscale and update qscale dependent variables.
  2330.  */
  2331. void ff_set_qscale(MpegEncContext * s, int qscale)
  2332. {
  2333.     if (qscale < 1)
  2334.         qscale = 1;
  2335.     else if (qscale > 31)
  2336.         qscale = 31;
  2338.     s->qscale = qscale;
  2339.     s->chroma_qscale= s->chroma_qscale_table[qscale];
  2341.     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
  2342.     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
  2343. }