Statistics
| Branch: | Revision:

ffmpeg / libavcodec / mpeg4video.h @ 2912e87a

History | View | Annotate | Download (5.8 KB)

1
/*
2
 * MPEG4 encoder/decoder internal header.
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This file is part of Libav.
7
 *
8
 * Libav is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * Libav is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with Libav; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
#ifndef AVCODEC_MPEG4VIDEO_H
24
#define AVCODEC_MPEG4VIDEO_H
25

    
26
#include <stdint.h>
27
#include "get_bits.h"
28
#include "mpegvideo.h"
29
#include "rl.h"
30

    
31
// shapes
32
#define RECT_SHAPE       0
33
#define BIN_SHAPE        1
34
#define BIN_ONLY_SHAPE   2
35
#define GRAY_SHAPE       3
36

    
37
#define SIMPLE_VO_TYPE             1
38
#define CORE_VO_TYPE               3
39
#define MAIN_VO_TYPE               4
40
#define NBIT_VO_TYPE               5
41
#define ARTS_VO_TYPE               10
42
#define ACE_VO_TYPE                12
43
#define ADV_SIMPLE_VO_TYPE         17
44

    
45
// aspect_ratio_info
46
#define EXTENDED_PAR 15
47

    
48
//vol_sprite_usage / sprite_enable
49
#define STATIC_SPRITE 1
50
#define GMC_SPRITE 2
51

    
52
#define MOTION_MARKER 0x1F001
53
#define DC_MARKER     0x6B001
54

    
55
#define VOS_STARTCODE        0x1B0
56
#define USER_DATA_STARTCODE  0x1B2
57
#define GOP_STARTCODE        0x1B3
58
#define VISUAL_OBJ_STARTCODE 0x1B5
59
#define VOP_STARTCODE        0x1B6
60

    
61
/* dc encoding for mpeg4 */
62
extern const uint8_t ff_mpeg4_DCtab_lum[13][2];
63
extern const uint8_t ff_mpeg4_DCtab_chrom[13][2];
64

    
65
extern const uint16_t ff_mpeg4_intra_vlc[103][2];
66
extern RLTable ff_mpeg4_rl_intra;
67

    
68
/* Note this is identical to the intra rvlc except that it is reordered. */
69
extern RLTable rvlc_rl_inter;
70
extern RLTable rvlc_rl_intra;
71

    
72
extern const uint16_t sprite_trajectory_tab[15][2];
73
extern const uint8_t mb_type_b_tab[4][2];
74

    
75
/* these matrixes will be permuted for the idct */
76
extern const int16_t ff_mpeg4_default_intra_matrix[64];
77
extern const int16_t ff_mpeg4_default_non_intra_matrix[64];
78

    
79
extern const uint8_t ff_mpeg4_y_dc_scale_table[32];
80
extern const uint8_t ff_mpeg4_c_dc_scale_table[32];
81
extern const uint16_t ff_mpeg4_resync_prefix[8];
82

    
83
extern const uint8_t mpeg4_dc_threshold[8];
84

    
85
void mpeg4_encode_mb(MpegEncContext *s,
86
                    DCTELEM block[6][64],
87
                    int motion_x, int motion_y);
88
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
89
                   int dir);
90
void ff_set_mpeg4_time(MpegEncContext * s);
91
void mpeg4_encode_picture_header(MpegEncContext *s, int picture_number);
92

    
93
int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb);
94
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s);
95
void ff_mpeg4_clean_buffers(MpegEncContext *s);
96
void ff_mpeg4_stuffing(PutBitContext * pbc);
97
void ff_mpeg4_init_partitions(MpegEncContext *s);
98
void ff_mpeg4_merge_partitions(MpegEncContext *s);
99
void ff_clean_mpeg4_qscales(MpegEncContext *s);
100
int ff_mpeg4_decode_partitions(MpegEncContext *s);
101
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s);
102
int mpeg4_decode_video_packet_header(MpegEncContext *s);
103
void ff_mpeg4_init_direct_mv(MpegEncContext *s);
104

    
105
/**
106
 *
107
 * @return the mb_type
108
 */
109
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my);
110

    
111
extern uint8_t ff_mpeg4_static_rl_table_store[3][2][2*MAX_RUN + MAX_LEVEL + 3];
112

    
113

    
114
#if 0 //3IV1 is quite rare and it slows things down a tiny bit
115
#define IS_3IV1 s->codec_tag == AV_RL32("3IV1")
116
#else
117
#define IS_3IV1 0
118
#endif
119

    
120

    
121
/**
122
 * predicts the dc.
123
 * encoding quantized level -> quantized diff
124
 * decoding quantized diff -> quantized level
125
 * @param n block index (0-3 are luma, 4-5 are chroma)
126
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
127
 */
128
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
129
{
130
    int a, b, c, wrap, pred, scale, ret;
131
    int16_t *dc_val;
132

    
133
    /* find prediction */
134
    if (n < 4) {
135
        scale = s->y_dc_scale;
136
    } else {
137
        scale = s->c_dc_scale;
138
    }
139
    if(IS_3IV1)
140
        scale= 8;
141

    
142
    wrap= s->block_wrap[n];
143
    dc_val = s->dc_val[0] + s->block_index[n];
144

    
145
    /* B C
146
     * A X
147
     */
148
    a = dc_val[ - 1];
149
    b = dc_val[ - 1 - wrap];
150
    c = dc_val[ - wrap];
151

    
152
    /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
153
    if(s->first_slice_line && n!=3){
154
        if(n!=2) b=c= 1024;
155
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
156
    }
157
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
158
        if(n==0 || n==4 || n==5)
159
            b=1024;
160
    }
161

    
162
    if (abs(a - b) < abs(b - c)) {
163
        pred = c;
164
        *dir_ptr = 1; /* top */
165
    } else {
166
        pred = a;
167
        *dir_ptr = 0; /* left */
168
    }
169
    /* we assume pred is positive */
170
    pred = FASTDIV((pred + (scale >> 1)), scale);
171

    
172
    if(encoding){
173
        ret = level - pred;
174
    }else{
175
        level += pred;
176
        ret= level;
177
        if(s->error_recognition>=3){
178
            if(level<0){
179
                av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
180
                return -1;
181
            }
182
            if(level*scale > 2048 + scale){
183
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
184
                return -1;
185
            }
186
        }
187
    }
188
    level *=scale;
189
    if(level&(~2047)){
190
        if(level<0)
191
            level=0;
192
        else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
193
            level=2047;
194
    }
195
    dc_val[0]= level;
196

    
197
    return ret;
198
}
199
#endif