/* * Generic DCT based hybrid video encoder * Copyright (c) 2000, 2001, 2002 Fabrice Bellard. * Copyright (c) 2002-2004 Michael Niedermayer * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *//** * @file mpegvideo.h * mpegvideo header. */#ifndef FFMPEG_MPEGVIDEO_H#define FFMPEG_MPEGVIDEO_H#include "dsputil.h"#include "bitstream.h"#include "ratecontrol.h"#include "parser.h"#include "mpeg12data.h"#include "rl.h"#define FRAME_SKIPPED 100 ///< return value for header parsers if frame is not codedenum OutputFormat {    FMT_MPEG1,    FMT_H261,    FMT_H263,    FMT_MJPEG,    FMT_H264,};#define MPEG_BUF_SIZE (16 * 1024)#define QMAT_SHIFT_MMX 16#define QMAT_SHIFT 22#define MAX_FCODE 7#define MAX_MV 2048#define MAX_THREADS 8#define MAX_PICTURE_COUNT 32#define ME_MAP_SIZE 64#define ME_MAP_SHIFT 3#define ME_MAP_MV_BITS 11#define MAX_MB_BYTES (30*16*16*3/8 + 120)#define INPLACE_OFFSET 16/* Start codes. */#define SEQ_END_CODE            0x000001b7#define SEQ_START_CODE          0x000001b3#define GOP_START_CODE          0x000001b8#define PICTURE_START_CODE      0x00000100#define SLICE_MIN_START_CODE    0x00000101#define SLICE_MAX_START_CODE    0x000001af#define EXT_START_CODE          0x000001b5#define USER_START_CODE         0x000001b2/** * Picture. */typedef struct Picture{    FF_COMMON_FRAME    /**     * halfpel luma planes.     */    uint8_t *interpolated[3];    int16_t (*motion_val_base[2])[2];    uint32_t *mb_type_base;#define MB_TYPE_INTRA MB_TYPE_INTRA4x4 //default mb_type if there is just one type#define IS_INTRA4x4(a)   ((a)&MB_TYPE_INTRA4x4)#define IS_INTRA16x16(a) ((a)&MB_TYPE_INTRA16x16)#define IS_PCM(a)        ((a)&MB_TYPE_INTRA_PCM)#define IS_INTRA(a)      ((a)&7)#define IS_INTER(a)      ((a)&(MB_TYPE_16x16|MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8))#define IS_SKIP(a)       ((a)&MB_TYPE_SKIP)#define IS_INTRA_PCM(a)  ((a)&MB_TYPE_INTRA_PCM)#define IS_INTERLACED(a) ((a)&MB_TYPE_INTERLACED)#define IS_DIRECT(a)     ((a)&MB_TYPE_DIRECT2)#define IS_GMC(a)        ((a)&MB_TYPE_GMC)#define IS_16X16(a)      ((a)&MB_TYPE_16x16)#define IS_16X8(a)       ((a)&MB_TYPE_16x8)#define IS_8X16(a)       ((a)&MB_TYPE_8x16)#define IS_8X8(a)        ((a)&MB_TYPE_8x8)#define IS_SUB_8X8(a)    ((a)&MB_TYPE_16x16) //note reused#define IS_SUB_8X4(a)    ((a)&MB_TYPE_16x8)  //note reused#define IS_SUB_4X8(a)    ((a)&MB_TYPE_8x16)  //note reused#define IS_SUB_4X4(a)    ((a)&MB_TYPE_8x8)   //note reused#define IS_ACPRED(a)     ((a)&MB_TYPE_ACPRED)#define IS_QUANT(a)      ((a)&MB_TYPE_QUANT)#define IS_DIR(a, part, list) ((a) & (MB_TYPE_P0L0<<((part)+2*(list))))#define USES_LIST(a, list) ((a) & ((MB_TYPE_P0L0|MB_TYPE_P1L0)<<(2*(list)))) ///< does this mb use listX, note does not work if subMBs#define HAS_CBP(a)        ((a)&MB_TYPE_CBP)    int field_poc[2];           ///< h264 top/bottom POC    int poc;                    ///< h264 frame POC    int frame_num;              ///< h264 frame_num (raw frame_num from slice header)    int pic_id;                 /**< h264 pic_num (short -> no wrap version of pic_num,                                     pic_num & max_pic_num; long -> long_pic_num) */    int long_ref;               ///< 1->long term reference 0->short term reference    int ref_poc[2][16];         ///< h264 POCs of the frames used as reference    int ref_count[2];           ///< number of entries in ref_poc    int mb_var_sum;             ///< sum of MB variance for current frame    int mc_mb_var_sum;          ///< motion compensated MB variance for current frame    uint16_t *mb_var;           ///< Table for MB variances    uint16_t *mc_mb_var;        ///< Table for motion compensated MB variances    uint8_t *mb_mean;           ///< Table for MB luminance    int32_t *mb_cmp_score;      ///< Table for MB cmp scores, for mb decision FIXME remove    int b_frame_score;          /* */} Picture;struct MpegEncContext;/** * Motion estimation context. */typedef struct MotionEstContext{    AVCodecContext *avctx;    int skip;                          ///< set if ME is skipped for the current MB    int co_located_mv[4][2];           ///< mv from last P-frame for direct mode ME    int direct_basis_mv[4][2];    uint8_t *scratchpad;               ///< data area for the ME algo, so that the ME does not need to malloc/free    uint8_t *best_mb;    uint8_t *temp_mb[2];    uint8_t *temp;    int best_bits;    uint32_t *map;                     ///< map to avoid duplicate evaluations    uint32_t *score_map;               ///< map to store the scores    int map_generation;    int pre_penalty_factor;    int penalty_factor;                /*!< an estimate of the bits required to                                        code a given mv value, e.g. (1,0) takes                                        more bits than (0,0). We have to                                        estimate whether any reduction in                                        residual is worth the extra bits. */    int sub_penalty_factor;    int mb_penalty_factor;    int flags;    int sub_flags;    int mb_flags;    int pre_pass;                      ///< = 1 for the pre pass    int dia_size;    int xmin;    int xmax;    int ymin;    int ymax;    int pred_x;    int pred_y;    uint8_t *src[4][4];    uint8_t *ref[4][4];    int stride;    int uvstride;    /* temp variables for picture complexity calculation */    int mc_mb_var_sum_temp;    int mb_var_sum_temp;    int scene_change_score;/*    cmp, chroma_cmp;*/    op_pixels_func (*hpel_put)[4];    op_pixels_func (*hpel_avg)[4];    qpel_mc_func (*qpel_put)[16];    qpel_mc_func (*qpel_avg)[16];    uint8_t (*mv_penalty)[MAX_MV*2+1];  ///< amount of bits needed to encode a MV    uint8_t *current_mv_penalty;    int (*sub_motion_search)(struct MpegEncContext * s,                                  int *mx_ptr, int *my_ptr, int dmin,                                  int src_index, int ref_index,                                  int size, int h);}MotionEstContext;/** * MpegEncContext. */typedef struct MpegEncContext {    struct AVCodecContext *avctx;    /* the following parameters must be initialized before encoding */    int width, height;///< picture size. must be a multiple of 16    int gop_size;    int intra_only;   ///< if true, only intra pictures are generated    int bit_rate;     ///< wanted bit rate    enum OutputFormat out_format; ///< output format    int h263_pred;    ///< use mpeg4/h263 ac/dc predictions/* the following codec id fields are deprecated in favor of codec_id */    int h263_plus;    ///< h263 plus headers    int h263_msmpeg4; ///< generate MSMPEG4 compatible stream (deprecated, use msmpeg4_version instead)    int h263_flv;     ///< use flv h263 header    enum CodecID codec_id;     /* see CODEC_ID_xxx */    int fixed_qscale; ///< fixed qscale if non zero    int encoding;     ///< true if we are encoding (vs decoding)    int flags;        ///< AVCodecContext.flags (HQ, MV4, ...)    int flags2;       ///< AVCodecContext.flags2    int max_b_frames; ///< max number of b-frames for encoding    int luma_elim_threshold;    int chroma_elim_threshold;    int strict_std_compliance; ///< strictly follow the std (MPEG4, ...)    int workaround_bugs;       ///< workaround bugs in encoders which cannot be detected automatically    int codec_tag;             ///< internal codec_tag upper case converted from avctx codec_tag    int stream_codec_tag;      ///< internal stream_codec_tag upper case converted from avctx stream_codec_tag    /* the following fields are managed internally by the encoder */    /** bit output */    PutBitContext pb;    /* sequence parameters */    int context_initialized;    int input_picture_number;  ///< used to set pic->display_picture_number, should not be used for/by anything else    int coded_picture_number;  ///< used to set pic->coded_picture_number, should not be used for/by anything else    int picture_number;       //FIXME remove, unclear definition    int picture_in_gop_number; ///< 0-> first pic in gop, ...    int b_frames_since_non_b;  ///< used for encoding, relative to not yet reordered input    int64_t user_specified_pts;///< last non zero pts from AVFrame which was passed into avcodec_encode_video()    int mb_width, mb_height;   ///< number of MBs horizontally & vertically    int mb_stride;             ///< mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11    int b8_stride;             ///< 2*mb_width+1 used for some 8x8 block arrays to allow simple addressing    int b4_stride;             ///< 4*mb_width+1 used for some 4x4 block arrays to allow simple addressing    int h_edge_pos, v_edge_pos;///< horizontal / vertical position of the right/bottom edge (pixel replication)    int mb_num;                ///< number of MBs of a picture    int linesize;              ///< line size, in bytes, may be different from width    int uvlinesize;            ///< line size, for chroma in bytes, may be different from width    Picture *picture;          ///< main picture buffer    Picture **input_picture;   ///< next pictures on display order for encoding    Picture **reordered_input_picture; ///< pointer to the next pictures in codedorder for encoding    int start_mb_y;            ///< start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)    int end_mb_y;              ///< end   mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)    struct MpegEncContext *thread_context[MAX_THREADS];    /**     * copy of the previous picture structure.     * note, linesize & data, might not match the previous picture (for field pictures)     */    Picture last_picture;    /**     * copy of the next picture structure.     * note, linesize & data, might not match the next picture (for field pictures)     */    Picture next_picture;    /**     * copy of the source picture structure for encoding.     * note, linesize & data, might not match the source picture (for field pictures)     */    Picture new_picture;    /**     * copy of the current picture structure.     * note, linesize & data, might not match the current picture (for field pictures)     */    Picture current_picture;    ///< buffer to store the decompressed current picture    Picture *last_picture_ptr;     ///< pointer to the previous picture.    Picture *next_picture_ptr;     ///< pointer to the next picture (for bidir pred)    Picture *current_picture_ptr;  ///< pointer to the current picture    uint8_t *visualization_buffer[3]; //< temporary buffer vor MV visualization    int last_dc[3];                ///< last DC values for MPEG1    int16_t *dc_val_base;    int16_t *dc_val[3];            ///< used for mpeg4 DC prediction, all 3 arrays must be continuous    int16_t dc_cache[4*5];    int y_dc_scale, c_dc_scale;    const uint8_t *y_dc_scale_table;     ///< qscale -> y_dc_scale table    const uint8_t *c_dc_scale_table;     ///< qscale -> c_dc_scale table    const uint8_t *chroma_qscale_table;  ///< qscale -> chroma_qscale (h263)    uint8_t *coded_block_base;    uint8_t *coded_block;          ///< used for coded block pattern prediction (msmpeg4v3, wmv1)    int16_t (*ac_val_base)[16];    int16_t (*ac_val[3])[16];      ///< used for for mpeg4 AC prediction, all 3 arrays must be continuous    int ac_pred;