← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mplayer2/oneiric-proposed

« back to all changes in this revision

Viewing changes to ffmpeg-mt/libavcodec/mpeg4video.h

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-03-20 22:48:03 UTC
  • Revision ID: james.westby@ubuntu.com-20110320224803-kc2nlrxz6pcphmf1
Tags: upstream-2.0~rc2
Import upstream version 2.0~rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg-mt/libavcodec/mpeg4video.h
 
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 FFmpeg.
 
7
 *
 
8
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; 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 const uint16_t inter_rvlc[170][2];
 
70
extern RLTable rvlc_rl_inter;
 
71
 
 
72
extern const uint16_t intra_rvlc[170][2];
 
73
extern RLTable rvlc_rl_intra;
 
74
 
 
75
extern const uint16_t sprite_trajectory_tab[15][2];
 
76
extern const uint8_t mb_type_b_tab[4][2];
 
77
 
 
78
/* these matrixes will be permuted for the idct */
 
79
extern const int16_t ff_mpeg4_default_intra_matrix[64];
 
80
extern const int16_t ff_mpeg4_default_non_intra_matrix[64];
 
81
 
 
82
extern const uint8_t ff_mpeg4_y_dc_scale_table[32];
 
83
extern const uint8_t ff_mpeg4_c_dc_scale_table[32];
 
84
extern const uint16_t ff_mpeg4_resync_prefix[8];
 
85
 
 
86
extern const uint8_t mpeg4_dc_threshold[8];
 
87
 
 
88
void mpeg4_encode_mb(MpegEncContext *s,
 
89
                    DCTELEM block[6][64],
 
90
                    int motion_x, int motion_y);
 
91
void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
 
92
                   int dir);
 
93
void ff_set_mpeg4_time(MpegEncContext * s);
 
94
void mpeg4_encode_picture_header(MpegEncContext *s, int picture_number);
 
95
 
 
96
int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb);
 
97
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s);
 
98
void ff_mpeg4_clean_buffers(MpegEncContext *s);
 
99
void ff_mpeg4_stuffing(PutBitContext * pbc);
 
100
void ff_mpeg4_init_partitions(MpegEncContext *s);
 
101
void ff_mpeg4_merge_partitions(MpegEncContext *s);
 
102
void ff_clean_mpeg4_qscales(MpegEncContext *s);
 
103
int ff_mpeg4_decode_partitions(MpegEncContext *s);
 
104
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s);
 
105
int mpeg4_decode_video_packet_header(MpegEncContext *s);
 
106
void ff_mpeg4_init_direct_mv(MpegEncContext *s);
 
107
 
 
108
/**
 
109
 *
 
110
 * @return the mb_type
 
111
 */
 
112
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my);
 
113
 
 
114
extern uint8_t ff_mpeg4_static_rl_table_store[3][2][2*MAX_RUN + MAX_LEVEL + 3];
 
115
 
 
116
 
 
117
#if 0 //3IV1 is quite rare and it slows things down a tiny bit
 
118
#define IS_3IV1 s->codec_tag == AV_RL32("3IV1")
 
119
#else
 
120
#define IS_3IV1 0
 
121
#endif
 
122
 
 
123
 
 
124
/**
 
125
 * predicts the dc.
 
126
 * encoding quantized level -> quantized diff
 
127
 * decoding quantized diff -> quantized level
 
128
 * @param n block index (0-3 are luma, 4-5 are chroma)
 
129
 * @param dir_ptr pointer to an integer where the prediction direction will be stored
 
130
 */
 
131
static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
 
132
{
 
133
    int a, b, c, wrap, pred, scale, ret;
 
134
    int16_t *dc_val;
 
135
 
 
136
    /* find prediction */
 
137
    if (n < 4) {
 
138
        scale = s->y_dc_scale;
 
139
    } else {
 
140
        scale = s->c_dc_scale;
 
141
    }
 
142
    if(IS_3IV1)
 
143
        scale= 8;
 
144
 
 
145
    wrap= s->block_wrap[n];
 
146
    dc_val = s->dc_val[0] + s->block_index[n];
 
147
 
 
148
    /* B C
 
149
     * A X
 
150
     */
 
151
    a = dc_val[ - 1];
 
152
    b = dc_val[ - 1 - wrap];
 
153
    c = dc_val[ - wrap];
 
154
 
 
155
    /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */
 
156
    if(s->first_slice_line && n!=3){
 
157
        if(n!=2) b=c= 1024;
 
158
        if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
 
159
    }
 
160
    if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
 
161
        if(n==0 || n==4 || n==5)
 
162
            b=1024;
 
163
    }
 
164
 
 
165
    if (abs(a - b) < abs(b - c)) {
 
166
        pred = c;
 
167
        *dir_ptr = 1; /* top */
 
168
    } else {
 
169
        pred = a;
 
170
        *dir_ptr = 0; /* left */
 
171
    }
 
172
    /* we assume pred is positive */
 
173
    pred = FASTDIV((pred + (scale >> 1)), scale);
 
174
 
 
175
    if(encoding){
 
176
        ret = level - pred;
 
177
    }else{
 
178
        level += pred;
 
179
        ret= level;
 
180
        if(s->error_recognition>=3){
 
181
            if(level<0){
 
182
                av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
 
183
                return -1;
 
184
            }
 
185
            if(level*scale > 2048 + scale){
 
186
                av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
 
187
                return -1;
 
188
            }
 
189
        }
 
190
    }
 
191
    level *=scale;
 
192
    if(level&(~2047)){
 
193
        if(level<0)
 
194
            level=0;
 
195
        else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
 
196
            level=2047;
 
197
    }
 
198
    dc_val[0]= level;
 
199
 
 
200
    return ret;
 
201
}
 
202
#endif