Mercurial > libavcodec.hg
annotate h263.c @ 5594:384629ebcb93 libavcodec
avoid overflow in the 3rd lifting step, this now needs mmx2 at minimum
(patch for plain mmx support is welcome ...)
author | michael |
---|---|
date | Sun, 26 Aug 2007 01:11:02 +0000 |
parents | 9f8219a3b86f |
children | c5ef5e6da9c5 |
rev | line source |
---|---|
0 | 1 /* |
2 * H263/MPEG4 backend for ffmpeg encoder and decoder | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
78 | 4 * H263+ support. |
0 | 5 * Copyright (c) 2001 Juan J. Sierralta P. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1708
diff
changeset
|
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 7 * |
5214 | 8 * ac prediction encoding, B-frame support, error resilience, optimizations, |
9 * qpel decoding, gmc decoding, interlaced decoding | |
10 * by Michael Niedermayer <michaelni@gmx.at> | |
11 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
12 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
13 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
14 * FFmpeg is free software; you can redistribute it and/or |
429 | 15 * modify it under the terms of the GNU Lesser General Public |
16 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
17 * version 2.1 of the License, or (at your option) any later version. |
0 | 18 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
19 * FFmpeg is distributed in the hope that it will be useful, |
0 | 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
22 * Lesser General Public License for more details. | |
0 | 23 * |
429 | 24 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
25 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3024
diff
changeset
|
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 27 */ |
1034 | 28 |
29 /** | |
30 * @file h263.c | |
1106 | 31 * h263/mpeg4 codec. |
1034 | 32 */ |
2967 | 33 |
355 | 34 //#define DEBUG |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
35 #include <limits.h> |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
36 |
0 | 37 #include "dsputil.h" |
38 #include "avcodec.h" | |
39 #include "mpegvideo.h" | |
40 #include "h263data.h" | |
41 #include "mpeg4data.h" | |
42 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
43 //#undef NDEBUG |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
44 //#include <assert.h> |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
45 |
544 | 46 #define INTRA_MCBPC_VLC_BITS 6 |
1482 | 47 #define INTER_MCBPC_VLC_BITS 7 |
544 | 48 #define CBPY_VLC_BITS 6 |
49 #define MV_VLC_BITS 9 | |
50 #define DC_VLC_BITS 9 | |
51 #define SPRITE_TRAJ_VLC_BITS 6 | |
52 #define MB_TYPE_B_VLC_BITS 4 | |
53 #define TEX_VLC_BITS 9 | |
1655 | 54 #define H263_MBTYPE_B_VLC_BITS 6 |
55 #define CBPC_B_VLC_BITS 3 | |
544 | 56 |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
57 #ifdef CONFIG_ENCODERS |
0 | 58 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
59 int n); |
78 | 60 static void h263p_encode_umotion(MpegEncContext * s, int val); |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
61 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
2967 | 62 int n, int dc, uint8_t *scan_table, |
453 | 63 PutBitContext *dc_pb, PutBitContext *ac_pb); |
3777 | 64 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
65 uint8_t *scan_table); | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
66 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
67 |
262 | 68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 69 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
71 int n, int coded); | |
453 | 72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 74 int n, int coded, int intra, int rvlc); |
3777 | 75 #ifdef CONFIG_ENCODERS |
3781 | 76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr); |
1424 | 77 static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
79 #endif //CONFIG_ENCODERS |
1914 | 80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); |
2003 | 81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding); |
1064 | 82 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
83 #ifdef CONFIG_ENCODERS |
1064 | 84 static uint8_t uni_DCtab_lum_len[512]; |
85 static uint8_t uni_DCtab_chrom_len[512]; | |
86 static uint16_t uni_DCtab_lum_bits[512]; | |
87 static uint16_t uni_DCtab_chrom_bits[512]; | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
88 |
4655 | 89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
1064 | 90 static uint8_t fcode_tab[MAX_MV*2+1]; |
91 static uint8_t umv_fcode_tab[MAX_MV*2+1]; | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
92 |
945 | 93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
94 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
96 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
2253 | 97 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; |
98 static uint8_t uni_h263_inter_rl_len [64*64*2*2]; | |
945 | 99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level)) |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 101 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
102 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
103 /* mpeg4 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
104 inter |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
105 max level: 24/6 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
106 max run: 53/63 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
107 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
108 intra |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
109 max level: 53/16 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
110 max run: 29/41 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
111 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
112 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
113 |
4672 | 114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3]; |
115 | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
117 #define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1") |
2967 | 118 #else |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
119 #define IS_3IV1 0 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
120 #endif |
293 | 121 |
0 | 122 int h263_get_picture_format(int width, int height) |
123 { | |
124 int format; | |
125 | |
126 if (width == 128 && height == 96) | |
355 | 127 format = 1; |
0 | 128 else if (width == 176 && height == 144) |
355 | 129 format = 2; |
0 | 130 else if (width == 352 && height == 288) |
355 | 131 format = 3; |
0 | 132 else if (width == 704 && height == 576) |
355 | 133 format = 4; |
0 | 134 else if (width == 1408 && height == 1152) |
355 | 135 format = 5; |
0 | 136 else |
137 format = 7; | |
138 return format; | |
139 } | |
140 | |
5403 | 141 static void show_pict_info(MpegEncContext *s){ |
142 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n", | |
143 s->qscale, av_get_pict_type_char(s->pict_type), | |
144 s->gb.size_in_bits, 1-s->no_rounding, | |
145 s->obmc ? " AP" : "", | |
146 s->umvplus ? " UMV" : "", | |
147 s->h263_long_vectors ? " LONG" : "", | |
148 s->h263_plus ? " +" : "", | |
149 s->h263_aic ? " AIC" : "", | |
150 s->alt_inter_vlc ? " AIV" : "", | |
151 s->modified_quant ? " MQ" : "", | |
152 s->loop_filter ? " LOOP" : "", | |
153 s->h263_slice_structured ? " SS" : "", | |
154 s->avctx->time_base.den, s->avctx->time_base.num | |
155 ); | |
156 } | |
157 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
158 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
159 |
1548 | 160 static void aspect_to_info(MpegEncContext * s, AVRational aspect){ |
887 | 161 int i; |
162 | |
1548 | 163 if(aspect.num==0) aspect= (AVRational){1,1}; |
164 | |
887 | 165 for(i=1; i<6; i++){ |
1548 | 166 if(av_cmp_q(pixel_aspect[i], aspect) == 0){ |
887 | 167 s->aspect_ratio_info=i; |
168 return; | |
169 } | |
170 } | |
2967 | 171 |
887 | 172 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 173 } |
174 | |
1354 | 175 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
0 | 176 { |
1354 | 177 int format; |
178 | |
179 align_put_bits(&s->pb); | |
180 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
181 put_bits(&s->pb, 17, 1); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
182 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ |
2637 | 183 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp |
184 s->avctx->time_base.den) & 0xff); /* TemporalReference */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
185 if (s->width == 352 && s->height == 288) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
186 format = 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
187 else if (s->width == 176 && s->height == 144) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
188 format = 3; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
189 else if (s->width == 128 && s->height == 96) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
190 format = 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
191 else if (s->width == 320 && s->height == 240) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
192 format = 5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
193 else if (s->width == 160 && s->height == 120) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
194 format = 6; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
195 else if (s->width <= 255 && s->height <= 255) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
196 format = 0; /* use 1 byte width & height */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
197 else |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
198 format = 1; /* use 2 bytes width & height */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
199 put_bits(&s->pb, 3, format); /* PictureSize */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
200 if (format == 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
201 put_bits(&s->pb, 8, s->width); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
202 put_bits(&s->pb, 8, s->height); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
203 } else if (format == 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
204 put_bits(&s->pb, 16, s->width); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
205 put_bits(&s->pb, 16, s->height); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
206 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
207 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */ |
1390
39d07c0263de
patch for flv deblocking by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1389
diff
changeset
|
208 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */ |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
209 put_bits(&s->pb, 5, s->qscale); /* Quantizer */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
210 put_bits(&s->pb, 1, 0); /* ExtraInformation */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
211 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
212 if(s->h263_aic){ |
2967 | 213 s->y_dc_scale_table= |
1639 | 214 s->c_dc_scale_table= ff_aic_dc_scale_table; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
215 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
216 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
217 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
218 } |
1354 | 219 } |
220 | |
221 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
222 { | |
1872 | 223 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref; |
224 int best_clock_code=1; | |
225 int best_divisor=60; | |
226 int best_error= INT_MAX; | |
2967 | 227 |
1872 | 228 if(s->h263_plus){ |
229 for(i=0; i<2; i++){ | |
230 int div, error; | |
2637 | 231 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den); |
5075
33d50e0e1823
Correct the parameter order for the call to "av_clip".
takis
parents:
4984
diff
changeset
|
232 div= av_clip(div, 1, 127); |
4001 | 233 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div); |
1872 | 234 if(error < best_error){ |
235 best_error= error; | |
236 best_divisor= div; | |
237 best_clock_code= i; | |
238 } | |
239 } | |
240 } | |
241 s->custom_pcf= best_clock_code!=1 || best_divisor!=60; | |
242 coded_frame_rate= 1800000; | |
243 coded_frame_rate_base= (1000+best_clock_code)*best_divisor; | |
1354 | 244 |
245 align_put_bits(&s->pb); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
246 |
231 | 247 /* Update the pointer to last GOB */ |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
248 s->ptr_lastgob = pbBufPtr(&s->pb); |
231 | 249 put_bits(&s->pb, 22, 0x20); /* PSC */ |
2637 | 250 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp |
251 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den); | |
1872 | 252 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */ |
0 | 253 |
2979 | 254 put_bits(&s->pb, 1, 1); /* marker */ |
255 put_bits(&s->pb, 1, 0); /* h263 id */ | |
256 put_bits(&s->pb, 1, 0); /* split screen off */ | |
257 put_bits(&s->pb, 1, 0); /* camera off */ | |
258 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
2967 | 259 |
78 | 260 format = h263_get_picture_format(s->width, s->height); |
0 | 261 if (!s->h263_plus) { |
262 /* H.263v1 */ | |
263 put_bits(&s->pb, 3, format); | |
264 put_bits(&s->pb, 1, (s->pict_type == P_TYPE)); | |
265 /* By now UMV IS DISABLED ON H.263v1, since the restrictions | |
266 of H.263v1 UMV implies to check the predicted MV after | |
267 calculation of the current MB to see if we're on the limits */ | |
2979 | 268 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ |
269 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
270 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ | |
271 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ | |
0 | 272 put_bits(&s->pb, 5, s->qscale); |
2979 | 273 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
0 | 274 } else { |
1872 | 275 int ufep=1; |
0 | 276 /* H.263v2 */ |
277 /* H.263 Plus PTYPE */ | |
2967 | 278 |
0 | 279 put_bits(&s->pb, 3, 7); |
1872 | 280 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */ |
78 | 281 if (format == 7) |
282 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
283 else | |
284 put_bits(&s->pb, 3, format); | |
2967 | 285 |
1872 | 286 put_bits(&s->pb,1, s->custom_pcf); |
1661 | 287 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 288 put_bits(&s->pb,1,0); /* SAC: off */ |
1633 | 289 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
290 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
1644 | 291 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ |
1661 | 292 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ |
0 | 293 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ |
294 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
1637 | 295 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ |
1644 | 296 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ |
0 | 297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
298 put_bits(&s->pb,3,0); /* Reserved */ | |
2967 | 299 |
0 | 300 put_bits(&s->pb, 3, s->pict_type == P_TYPE); |
2967 | 301 |
0 | 302 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ |
303 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
304 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 305 put_bits(&s->pb,2,0); /* Reserved */ |
306 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
2967 | 307 |
0 | 308 /* This should be here if PLUSPTYPE */ |
2979 | 309 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
310 | |
311 if (format == 7) { | |
78 | 312 /* Custom Picture Format (CPFMT) */ |
1548 | 313 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 314 |
315 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 316 put_bits(&s->pb,9,(s->width >> 2) - 1); |
317 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
318 put_bits(&s->pb,9,(s->height >> 2)); | |
1548 | 319 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
320 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
321 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
2979 | 322 } |
78 | 323 } |
1872 | 324 if(s->custom_pcf){ |
325 if(ufep){ | |
326 put_bits(&s->pb, 1, best_clock_code); | |
327 put_bits(&s->pb, 7, best_divisor); | |
328 } | |
329 put_bits(&s->pb, 2, (temp_ref>>8)&3); | |
330 } | |
2967 | 331 |
0 | 332 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
333 if (s->umvplus) |
1089 | 334 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
1644 | 335 //FIXME check actual requested range |
1089 | 336 put_bits(&s->pb,2,1); /* unlimited */ |
1661 | 337 if(s->h263_slice_structured) |
338 put_bits(&s->pb,2,0); /* no weird submodes */ | |
1089 | 339 |
0 | 340 put_bits(&s->pb, 5, s->qscale); |
341 } | |
342 | |
2979 | 343 put_bits(&s->pb, 1, 0); /* no PEI */ |
498 | 344 |
1670 | 345 if(s->h263_slice_structured){ |
346 put_bits(&s->pb, 1, 1); | |
2967 | 347 |
1670 | 348 assert(s->mb_x == 0 && s->mb_y == 0); |
349 ff_h263_encode_mba(s); | |
350 | |
351 put_bits(&s->pb, 1, 1); | |
352 } | |
353 | |
498 | 354 if(s->h263_aic){ |
2967 | 355 s->y_dc_scale_table= |
1639 | 356 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 357 }else{ |
358 s->y_dc_scale_table= | |
359 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
360 } | |
0 | 361 } |
362 | |
766 | 363 /** |
364 * Encodes a group of blocks header. | |
365 */ | |
1661 | 366 void h263_encode_gob_header(MpegEncContext * s, int mb_line) |
162 | 367 { |
1661 | 368 put_bits(&s->pb, 17, 1); /* GBSC */ |
369 | |
370 if(s->h263_slice_structured){ | |
371 put_bits(&s->pb, 1, 1); | |
372 | |
373 ff_h263_encode_mba(s); | |
374 | |
375 if(s->mb_num > 1583) | |
376 put_bits(&s->pb, 1, 1); | |
377 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
378 put_bits(&s->pb, 1, 1); | |
379 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ | |
380 }else{ | |
381 int gob_number= mb_line / s->gob_index; | |
382 | |
383 put_bits(&s->pb, 5, gob_number); /* GN */ | |
384 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ | |
385 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
386 } | |
162 | 387 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
388 |
1492 | 389 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ |
390 int last=0; | |
391 int j; | |
392 int rate=0; | |
393 | |
394 for(j=1; j<=block_last_index; j++){ | |
395 const int index= scantable[j]; | |
396 int level= block[index]; | |
397 if(level){ | |
398 level+= 64; | |
399 if((level&(~127)) == 0){ | |
400 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; | |
401 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; | |
402 }else | |
403 rate += s->ac_esc_length; | |
404 level-= 64; | |
405 | |
406 last= j; | |
407 } | |
408 } | |
2967 | 409 |
1492 | 410 return rate; |
411 } | |
412 | |
413 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
414 { |
1492 | 415 int score= 0; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
416 int i, n; |
903 | 417 int8_t * const qscale_table= s->current_picture.qscale_table; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
418 |
1492 | 419 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); |
2967 | 420 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
421 for(n=0; n<6; n++){ |
1064 | 422 int16_t *ac_val, *ac_val1; |
2967 | 423 |
1492 | 424 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
425 |
266 | 426 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
427 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
428 if(dir[n]){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
429 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
430 /* top prediction */ |
266 | 431 ac_val-= s->block_wrap[n]*16; |
903 | 432 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
433 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
434 for(i=1; i<8; i++){ |
1092 | 435 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 436 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; |
1092 | 437 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
438 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
439 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
440 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
441 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
442 for(i=1; i<8; i++){ |
1092 | 443 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 444 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
1092 | 445 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
446 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
447 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
448 } |
1492 | 449 st[n]= s->intra_h_scantable.permutated; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
450 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
451 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
452 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
453 ac_val-= 16; |
903 | 454 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
455 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
456 for(i=1; i<8; i++){ |
1092 | 457 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 458 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
459 ac_val1[i ]= level; |
1092 | 460 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
461 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
462 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
463 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
464 for(i=1; i<8; i++){ |
1092 | 465 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 466 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
467 ac_val1[i ]= level; |
1092 | 468 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
469 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
470 } |
1492 | 471 st[n]= s->intra_v_scantable.permutated; |
472 } | |
473 | |
474 for(i=63; i>0; i--) //FIXME optimize | |
475 if(block[n][ st[n][i] ]) break; | |
476 s->block_last_index[n]= i; | |
477 | |
478 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); | |
479 } | |
480 | |
481 return score < 0; | |
482 } | |
483 | |
484 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
485 { | |
486 int i, n; | |
487 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); | |
488 | |
489 for(n=0; n<6; n++){ | |
490 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
491 | |
492 st[n]= s->intra_scantable.permutated; | |
493 if(dir[n]){ | |
494 /* top prediction */ | |
495 for(i=1; i<8; i++){ | |
496 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8]; | |
497 } | |
498 }else{ | |
499 /* left prediction */ | |
500 for(i=1; i<8; i++){ | |
501 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ]; | |
502 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
503 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
504 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
505 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
506 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
507 /** |
4316 | 508 * init s->current_picture.qscale_table from s->lambda_table |
509 */ | |
510 static void ff_init_qscale_tab(MpegEncContext *s){ | |
511 int8_t * const qscale_table= s->current_picture.qscale_table; | |
512 int i; | |
513 | |
514 for(i=0; i<s->mb_num; i++){ | |
515 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ]; | |
516 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); | |
4594 | 517 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax); |
4316 | 518 } |
519 } | |
520 | |
521 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
522 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
523 */ |
695 | 524 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
525 int i; |
903 | 526 int8_t * const qscale_table= s->current_picture.qscale_table; |
2967 | 527 |
4316 | 528 ff_init_qscale_tab(s); |
529 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
530 for(i=1; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
531 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
532 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
533 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
534 for(i=s->mb_num-2; i>=0; i--){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
535 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
536 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
537 } |
1983 | 538 |
539 if(s->codec_id != CODEC_ID_H263P){ | |
540 for(i=1; i<s->mb_num; i++){ | |
541 int mb_xy= s->mb_index2xy[i]; | |
2967 | 542 |
1983 | 543 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ |
544 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER; | |
545 } | |
546 } | |
547 } | |
695 | 548 } |
549 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
550 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
551 * modify mb_type & qscale so that encoding is acually possible in mpeg4 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
552 */ |
695 | 553 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
554 int i; | |
903 | 555 int8_t * const qscale_table= s->current_picture.qscale_table; |
556 | |
695 | 557 ff_clean_h263_qscales(s); |
2967 | 558 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
559 if(s->pict_type== B_TYPE){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
560 int odd=0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
561 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */ |
2967 | 562 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
563 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
564 int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
565 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
566 } |
2967 | 567 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
568 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
569 else odd=0; |
2967 | 570 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
571 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
572 int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
573 if((qscale_table[mb_xy]&1) != odd) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
574 qscale_table[mb_xy]++; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
575 if(qscale_table[mb_xy] > 31) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
576 qscale_table[mb_xy]= 31; |
2967 | 577 } |
578 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
579 for(i=1; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
580 int mb_xy= s->mb_index2xy[i]; |
1708 | 581 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ |
582 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
583 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
584 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
585 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
586 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
587 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
588 #endif //CONFIG_ENCODERS |
3247 | 589 |
3256 | 590 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t))) |
3255
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
591 #define tab_bias (tab_size/2) |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
592 |
3791
b1d5ef809e11
fix rv20 b frames (broke since r5264 Mon Apr 3 07:52:24 2006 UTC 2x faster ff_mpeg4_set_direct_mv)
michael
parents:
3781
diff
changeset
|
593 void ff_mpeg4_init_direct_mv(MpegEncContext *s){ |
3247 | 594 int i; |
595 for(i=0; i<tab_size; i++){ | |
596 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time; | |
597 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time; | |
598 } | |
599 } | |
600 | |
601 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){ | |
602 int xy= s->block_index[i]; | |
603 uint16_t time_pp= s->pp_time; | |
604 uint16_t time_pb= s->pb_time; | |
605 int p_mx, p_my; | |
606 | |
607 p_mx= s->next_picture.motion_val[0][xy][0]; | |
608 if((unsigned)(p_mx + tab_bias) < tab_size){ | |
609 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; | |
610 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
611 : s->direct_scale_mv[1][p_mx + tab_bias]; | |
612 }else{ | |
613 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx; | |
614 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
615 : p_mx*(time_pb - time_pp)/time_pp; | |
616 } | |
617 p_my= s->next_picture.motion_val[0][xy][1]; | |
618 if((unsigned)(p_my + tab_bias) < tab_size){ | |
619 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; | |
620 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
621 : s->direct_scale_mv[1][p_my + tab_bias]; | |
622 }else{ | |
623 s->mv[0][i][1] = p_my*time_pb/time_pp + my; | |
624 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
625 : p_my*(time_pb - time_pp)/time_pp; | |
626 } | |
627 } | |
628 | |
3255
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
629 #undef tab_size |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
630 #undef tab_bias |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
631 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
632 /** |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
633 * |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
634 * @return the mb_type |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
635 */ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
636 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
637 const int mb_index= s->mb_x + s->mb_y*s->mb_stride; |
1708 | 638 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; |
936 | 639 uint16_t time_pp= s->pp_time; |
640 uint16_t time_pb= s->pb_time; | |
641 int i; | |
2967 | 642 |
936 | 643 //FIXME avoid divides |
3247 | 644 // try special case with shifts for 1 and 3 B-frames? |
2967 | 645 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
646 if(IS_8X8(colocated_mb_type)){ |
936 | 647 s->mv_type = MV_TYPE_8X8; |
648 for(i=0; i<4; i++){ | |
3247 | 649 ff_mpeg4_set_one_direct_mv(s, mx, my, i); |
936 | 650 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
651 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
652 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 653 s->mv_type = MV_TYPE_FIELD; |
654 for(i=0; i<2; i++){ | |
1948 | 655 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]]; |
3205 | 656 s->field_select[0][i]= field_select; |
657 s->field_select[1][i]= i; | |
936 | 658 if(s->top_field_first){ |
1948 | 659 time_pp= s->pp_field_time - field_select + i; |
660 time_pb= s->pb_field_time - field_select + i; | |
936 | 661 }else{ |
1948 | 662 time_pp= s->pp_field_time + field_select - i; |
663 time_pb= s->pb_field_time + field_select - i; | |
936 | 664 } |
1708 | 665 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; |
666 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; | |
667 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0] | |
668 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp; | |
2967 | 669 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] |
1708 | 670 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp; |
936 | 671 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
672 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
673 }else{ |
3247 | 674 ff_mpeg4_set_one_direct_mv(s, mx, my, 0); |
675 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0]; | |
676 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1]; | |
677 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0]; | |
678 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1]; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
679 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
680 s->mv_type= MV_TYPE_16X16; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
681 else |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
682 s->mv_type= MV_TYPE_8X8; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
683 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 684 } |
685 } | |
686 | |
1389 | 687 void ff_h263_update_motion_val(MpegEncContext * s){ |
688 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
689 //FIXME a lot of that is only needed for !low_delay |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
690 const int wrap = s->b8_stride; |
1389 | 691 const int xy = s->block_index[0]; |
2967 | 692 |
693 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped; | |
1389 | 694 |
695 if(s->mv_type != MV_TYPE_8X8){ | |
696 int motion_x, motion_y; | |
697 if (s->mb_intra) { | |
698 motion_x = 0; | |
699 motion_y = 0; | |
700 } else if (s->mv_type == MV_TYPE_16X16) { | |
701 motion_x = s->mv[0][0][0]; | |
702 motion_y = s->mv[0][0][1]; | |
703 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { | |
704 int i; | |
705 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; | |
706 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; | |
707 motion_x = (motion_x>>1) | (motion_x&1); | |
708 for(i=0; i<2; i++){ | |
1708 | 709 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0]; |
710 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1]; | |
1389 | 711 } |
1948 | 712 s->current_picture.ref_index[0][xy ]= |
713 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0]; | |
714 s->current_picture.ref_index[0][xy + wrap ]= | |
715 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1]; | |
1389 | 716 } |
1948 | 717 |
1389 | 718 /* no update if 8X8 because it has been done during parsing */ |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
719 s->current_picture.motion_val[0][xy][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
720 s->current_picture.motion_val[0][xy][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
721 s->current_picture.motion_val[0][xy + 1][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
722 s->current_picture.motion_val[0][xy + 1][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
723 s->current_picture.motion_val[0][xy + wrap][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
724 s->current_picture.motion_val[0][xy + wrap][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
725 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
726 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; |
1389 | 727 } |
728 | |
729 if(s->encoding){ //FIXME encoding MUST be cleaned up | |
2967 | 730 if (s->mv_type == MV_TYPE_8X8) |
1389 | 731 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; |
1633 | 732 else if(s->mb_intra) |
733 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; | |
1389 | 734 else |
735 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | |
736 } | |
737 } | |
738 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
739 #ifdef CONFIG_ENCODERS |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
740 |
2502 | 741 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){ |
742 int l, bit_size, code; | |
743 | |
744 if (val == 0) { | |
745 return mvtab[0][1]; | |
746 } else { | |
747 bit_size = f_code - 1; | |
748 /* modulo encoding */ | |
749 l= INT_BIT - 6 - bit_size; | |
750 val = (val<<l)>>l; | |
751 val--; | |
752 code = (val >> bit_size) + 1; | |
753 | |
754 return mvtab[code][1] + 1 + bit_size; | |
755 } | |
756 } | |
757 | |
758 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){ | |
759 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
2967 | 760 skip_put_bits(&s->pb, |
2502 | 761 h263_get_motion_length(s, x, f_code) |
762 +h263_get_motion_length(s, y, f_code)); | |
763 }else{ | |
764 ff_h263_encode_motion(s, x, f_code); | |
765 ff_h263_encode_motion(s, y, f_code); | |
766 } | |
767 } | |
768 | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
769 static inline int get_p_cbp(MpegEncContext * s, |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
770 DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
771 int motion_x, int motion_y){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
772 int cbp, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
773 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
774 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
775 int best_cbpy_score= INT_MAX; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
776 int best_cbpc_score= INT_MAX; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
777 int cbpc = (-1), cbpy= (-1); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
778 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0); |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1492
diff
changeset
|
779 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
780 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
781 for(i=0; i<4; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
782 int score= inter_MCBPC_bits[i + offset] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
783 if(i&1) score += s->coded_score[5]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
784 if(i&2) score += s->coded_score[4]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
785 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
786 if(score < best_cbpc_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
787 best_cbpc_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
788 cbpc= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
789 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
790 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
791 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
792 for(i=0; i<16; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
793 int score= cbpy_tab[i ^ 0xF][1] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
794 if(i&1) score += s->coded_score[3]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
795 if(i&2) score += s->coded_score[2]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
796 if(i&4) score += s->coded_score[1]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
797 if(i&8) score += s->coded_score[0]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
798 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
799 if(score < best_cbpy_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
800 best_cbpy_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
801 cbpy= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
802 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
803 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
804 cbp= cbpc + 4*cbpy; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
805 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
806 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
807 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
808 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
809 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
810 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
811 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
812 s->block_last_index[i]= -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
813 memset(s->block[i], 0, sizeof(DCTELEM)*64); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
814 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
815 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
816 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
817 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
818 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
819 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
820 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
821 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
822 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
823 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
824 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
825 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
826 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
827 int motion_x, int motion_y, int mb_type){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
828 int cbp=0, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
829 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
830 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
831 int score=0; |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1492
diff
changeset
|
832 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 833 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
834 for(i=0; i<6; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
835 if(s->coded_score[i] < 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
836 score += s->coded_score[i]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
837 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
838 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
839 } |
2967 | 840 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
841 if(cbp){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
842 int zero_score= -6; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
843 if ((motion_x | motion_y | s->dquant | mb_type) == 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
844 zero_score-= 4; //2*MV + mb_type + cbp bit |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
845 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
846 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
847 zero_score*= lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
848 if(zero_score <= score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
849 cbp=0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
850 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
851 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
852 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
853 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
854 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
855 s->block_last_index[i]= -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
856 memset(s->block[i], 0, sizeof(DCTELEM)*64); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
857 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
858 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
859 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
860 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
861 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
862 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
863 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
864 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
865 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
866 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
867 |
2967 | 868 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], |
2502 | 869 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){ |
870 int i; | |
2967 | 871 |
2502 | 872 if(scan_table){ |
873 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
874 for (i = 0; i < 6; i++) { | |
875 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i])); | |
876 } | |
877 }else{ | |
878 /* encode each block */ | |
879 for (i = 0; i < 6; i++) { | |
880 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb); | |
881 } | |
882 } | |
883 }else{ | |
884 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
885 for (i = 0; i < 6; i++) { | |
886 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated)); | |
887 } | |
888 }else{ | |
889 /* encode each block */ | |
890 for (i = 0; i < 6; i++) { | |
891 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb); | |
892 } | |
893 } | |
894 } | |
895 } | |
896 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
897 void mpeg4_encode_mb(MpegEncContext * s, |
2979 | 898 DCTELEM block[6][64], |
899 int motion_x, int motion_y) | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
900 { |
1057 | 901 int cbpc, cbpy, pred_x, pred_y; |
453 | 902 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
903 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb; | |
904 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb; | |
905 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
906 const int dquant_code[5]= {1,0,9,2,3}; |
2967 | 907 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
908 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
909 if (!s->mb_intra) { |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
910 int i, cbp; |
2967 | 911 |
324 | 912 if(s->pict_type==B_TYPE){ |
5445
5581a40c673a
exchange the values of MV_DIR_FORWARD and MV_DIR_BACKWARD (this is more sane,
michael
parents:
5405
diff
changeset
|
913 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ |
324 | 914 int mb_type= mb_type_table[s->mv_dir]; |
1708 | 915 |
324 | 916 if(s->mb_x==0){ |
1708 | 917 for(i=0; i<2; i++){ |
2967 | 918 s->last_mv[i][0][0]= |
919 s->last_mv[i][0][1]= | |
920 s->last_mv[i][1][0]= | |
1708 | 921 s->last_mv[i][1][1]= 0; |
922 } | |
324 | 923 } |
2967 | 924 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
925 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
926 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
927 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
928 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
929 /* nothing to do if this MB was skipped in the next P Frame */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
930 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 931 s->skip_count++; |
2967 | 932 s->mv[0][0][0]= |
933 s->mv[0][0][1]= | |
934 s->mv[1][0][0]= | |
324 | 935 s->mv[1][0][1]= 0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
936 s->mv_dir= MV_DIR_FORWARD; //doesn't matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
937 s->qscale -= s->dquant; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
938 // s->mb_skipped=1; |
903 | 939 |
324 | 940 return; |
941 } | |
2967 | 942 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
943 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); |
2967 | 944 |
324 | 945 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
946 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
947 assert(s->dquant==0); |
2967 | 948 |
324 | 949 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 950 |
951 if(interleaved_stats){ | |
952 s->misc_bits++; | |
953 s->last_bits++; | |
954 } | |
324 | 955 s->skip_count++; |
956 return; | |
957 } | |
2967 | 958 |
2979 | 959 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
324 | 960 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
961 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) |
324 | 962 if(cbp) put_bits(&s->pb, 6, cbp); |
2967 | 963 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
964 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
965 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
966 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
967 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
968 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
969 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
970 s->qscale -= s->dquant; |
2967 | 971 |
697 | 972 if(!s->progressive_sequence){ |
973 if(cbp) | |
974 put_bits(&s->pb, 1, s->interlaced_dct); | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
975 if(mb_type) // not direct mode |
1708 | 976 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD); |
697 | 977 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
978 |
453 | 979 if(interleaved_stats){ |
1164 | 980 s->misc_bits+= get_bits_diff(s); |
453 | 981 } |
295 | 982 |
1708 | 983 if(mb_type == 0){ |
984 assert(s->mv_dir & MV_DIRECT); | |
2502 | 985 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1); |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
986 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
987 s->f_count++; |
1708 | 988 }else{ |
989 assert(mb_type > 0 && mb_type < 4); | |
990 if(s->mv_type != MV_TYPE_FIELD){ | |
991 if(s->mv_dir & MV_DIR_FORWARD){ | |
2502 | 992 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0], |
993 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
1708 | 994 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0]; |
995 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1]; | |
996 s->f_count++; | |
997 } | |
998 if(s->mv_dir & MV_DIR_BACKWARD){ | |
2502 | 999 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0], |
1000 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
1708 | 1001 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0]; |
1002 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1]; | |
1003 s->b_count++; | |
1004 } | |
1005 }else{ | |
1006 if(s->mv_dir & MV_DIR_FORWARD){ | |
1007 put_bits(&s->pb, 1, s->field_select[0][0]); | |
1008 put_bits(&s->pb, 1, s->field_select[0][1]); | |
1009 } | |
1010 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1011 put_bits(&s->pb, 1, s->field_select[1][0]); | |
1012 put_bits(&s->pb, 1, s->field_select[1][1]); | |
1013 } | |
1014 if(s->mv_dir & MV_DIR_FORWARD){ | |
1015 for(i=0; i<2; i++){ | |
2502 | 1016 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] , |
1017 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code); | |
1708 | 1018 s->last_mv[0][i][0]= s->mv[0][i][0]; |
1019 s->last_mv[0][i][1]= s->mv[0][i][1]*2; | |
1020 } | |
1021 s->f_count++; | |
1022 } | |
1023 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1024 for(i=0; i<2; i++){ | |
2502 | 1025 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] , |
1026 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code); | |
1708 | 1027 s->last_mv[1][i][0]= s->mv[1][i][0]; |
1028 s->last_mv[1][i][1]= s->mv[1][i][1]*2; | |
1029 } | |
1030 s->b_count++; | |
1031 } | |
1032 } | |
324 | 1033 } |
453 | 1034 |
1035 if(interleaved_stats){ | |
1164 | 1036 s->mv_bits+= get_bits_diff(s); |
453 | 1037 } |
295 | 1038 |
2502 | 1039 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb); |
453 | 1040 |
1041 if(interleaved_stats){ | |
1164 | 1042 s->p_tex_bits+= get_bits_diff(s); |
453 | 1043 } |
1708 | 1044 |
324 | 1045 }else{ /* s->pict_type==B_TYPE */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1046 cbp= get_p_cbp(s, block, motion_x, motion_y); |
2967 | 1047 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1048 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
2967 | 1049 /* check if the B frames can skip it too, as we must skip it if we skip here |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
1050 why didn't they just compress the skip-mb bits instead of reusing them ?! */ |
331 | 1051 if(s->max_b_frames>0){ |
1052 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1053 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1054 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1055 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1056 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1057 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1058 if(x+16 > s->width) x= s->width-16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1059 if(y+16 > s->height) y= s->height-16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1060 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1061 offset= x + y*s->linesize; |
903 | 1062 p_pic= s->new_picture.data[0] + offset; |
2967 | 1063 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1064 s->mb_skipped=1; |
331 | 1065 for(i=0; i<s->max_b_frames; i++){ |
339 | 1066 uint8_t *b_pic; |
1067 int diff; | |
903 | 1068 Picture *pic= s->reordered_input_picture[i+1]; |
1069 | |
1070 if(pic==NULL || pic->pict_type!=B_TYPE) break; | |
1071 | |
3068 | 1072 b_pic= pic->data[0] + offset; |
1073 if(pic->type != FF_BUFFER_TYPE_SHARED) | |
1074 b_pic+= INPLACE_OFFSET; | |
2979 | 1075 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16); |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1076 if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1077 s->mb_skipped=0; |
331 | 1078 break; |
1079 } | |
1080 } | |
1081 }else | |
2967 | 1082 s->mb_skipped=1; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1083 |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1084 if(s->mb_skipped==1){ |
331 | 1085 /* skip macroblock */ |
1086 put_bits(&s->pb, 1, 1); | |
453 | 1087 |
1088 if(interleaved_stats){ | |
1089 s->misc_bits++; | |
1090 s->last_bits++; | |
1091 } | |
331 | 1092 s->skip_count++; |
2967 | 1093 |
331 | 1094 return; |
1095 } | |
295 | 1096 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1097 |
2979 | 1098 put_bits(&s->pb, 1, 0); /* mb coded */ |
1633 | 1099 cbpc = cbp & 3; |
1100 cbpy = cbp >> 2; | |
1101 cbpy ^= 0xf; | |
324 | 1102 if(s->mv_type==MV_TYPE_16X16){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1103 if(s->dquant) cbpc+= 8; |
324 | 1104 put_bits(&s->pb, |
1105 inter_MCBPC_bits[cbpc], | |
1106 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1107 |
453 | 1108 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1109 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1110 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 1111 |
1112 if(!s->progressive_sequence){ | |
1113 if(cbp) | |
1114 put_bits(pb2, 1, s->interlaced_dct); | |
1708 | 1115 put_bits(pb2, 1, 0); |
697 | 1116 } |
2967 | 1117 |
453 | 1118 if(interleaved_stats){ |
1164 | 1119 s->misc_bits+= get_bits_diff(s); |
453 | 1120 } |
324 | 1121 |
1122 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1123 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1124 |
2502 | 1125 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1126 motion_y - pred_y, s->f_code); | |
1708 | 1127 }else if(s->mv_type==MV_TYPE_FIELD){ |
1128 if(s->dquant) cbpc+= 8; | |
1129 put_bits(&s->pb, | |
1130 inter_MCBPC_bits[cbpc], | |
1131 inter_MCBPC_code[cbpc]); | |
1132 | |
1133 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1134 if(s->dquant) | |
1135 put_bits(pb2, 2, dquant_code[s->dquant+2]); | |
1136 | |
1137 assert(!s->progressive_sequence); | |
1138 if(cbp) | |
1139 put_bits(pb2, 1, s->interlaced_dct); | |
1140 put_bits(pb2, 1, 1); | |
2967 | 1141 |
1708 | 1142 if(interleaved_stats){ |
1143 s->misc_bits+= get_bits_diff(s); | |
1144 } | |
1145 | |
1146 /* motion vectors: 16x8 interlaced mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1147 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1708 | 1148 pred_y /=2; |
2967 | 1149 |
1708 | 1150 put_bits(&s->pb, 1, s->field_select[0][0]); |
1151 put_bits(&s->pb, 1, s->field_select[0][1]); | |
2967 | 1152 |
2502 | 1153 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x, |
1154 s->mv[0][0][1] - pred_y, s->f_code); | |
1155 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x, | |
1156 s->mv[0][1][1] - pred_y, s->f_code); | |
324 | 1157 }else{ |
1708 | 1158 assert(s->mv_type==MV_TYPE_8X8); |
324 | 1159 put_bits(&s->pb, |
1633 | 1160 inter_MCBPC_bits[cbpc+16], |
1161 inter_MCBPC_code[cbpc+16]); | |
453 | 1162 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
1163 | |
757 | 1164 if(!s->progressive_sequence){ |
1165 if(cbp) | |
1166 put_bits(pb2, 1, s->interlaced_dct); | |
1167 } | |
2967 | 1168 |
453 | 1169 if(interleaved_stats){ |
1164 | 1170 s->misc_bits+= get_bits_diff(s); |
453 | 1171 } |
324 | 1172 |
1173 for(i=0; i<4; i++){ | |
1174 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1175 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
324 | 1176 |
2502 | 1177 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, |
1178 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); | |
324 | 1179 } |
1180 } | |
453 | 1181 |
2967 | 1182 if(interleaved_stats){ |
1164 | 1183 s->mv_bits+= get_bits_diff(s); |
453 | 1184 } |
324 | 1185 |
2502 | 1186 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb); |
453 | 1187 |
1188 if(interleaved_stats){ | |
1164 | 1189 s->p_tex_bits+= get_bits_diff(s); |
453 | 1190 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
1191 s->f_count++; |
295 | 1192 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1193 } else { |
324 | 1194 int cbp; |
2967 | 1195 int dc_diff[6]; //dc values with the dc prediction subtracted |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1196 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1197 int zigzag_last_index[6]; |
2979 | 1198 uint8_t *scan_table[6]; |
1057 | 1199 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1200 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1201 for(i=0; i<6; i++){ |
2003 | 1202 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1203 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1204 |
1492 | 1205 if(s->flags & CODEC_FLAG_AC_PRED){ |
1206 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); | |
1207 if(!s->ac_pred) | |
1208 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1209 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1210 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1211 scan_table[i]= s->intra_scantable.permutated; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1212 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1213 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1214 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1215 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1216 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1217 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1218 cbp |= 1 << (5 - i); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1219 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1220 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1221 cbpc = cbp & 3; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1222 if (s->pict_type == I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1223 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1224 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1225 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1226 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1227 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1228 if(s->dquant) cbpc+=8; |
2979 | 1229 put_bits(&s->pb, 1, 0); /* mb coded */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1230 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1231 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1232 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1233 } |
453 | 1234 put_bits(pb2, 1, s->ac_pred); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1235 cbpy = cbp >> 2; |
453 | 1236 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1237 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1238 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 1239 |
697 | 1240 if(!s->progressive_sequence){ |
1241 put_bits(dc_pb, 1, s->interlaced_dct); | |
1242 } | |
1243 | |
453 | 1244 if(interleaved_stats){ |
1164 | 1245 s->misc_bits+= get_bits_diff(s); |
453 | 1246 } |
286 | 1247 |
2502 | 1248 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1249 |
453 | 1250 if(interleaved_stats){ |
1164 | 1251 s->i_tex_bits+= get_bits_diff(s); |
453 | 1252 } |
286 | 1253 s->i_count++; |
1254 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1255 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
1492 | 1256 if(s->ac_pred) |
1257 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1258 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1259 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1260 |
0 | 1261 void h263_encode_mb(MpegEncContext * s, |
2979 | 1262 DCTELEM block[6][64], |
1263 int motion_x, int motion_y) | |
0 | 1264 { |
1265 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 1266 int16_t pred_dc; |
1267 int16_t rec_intradc[6]; | |
3781 | 1268 int16_t *dc_ptr[6]; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1269 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
695 | 1270 const int dquant_code[5]= {1,0,9,2,3}; |
2967 | 1271 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1272 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
324 | 1273 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1274 /* compute cbp */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1275 cbp= get_p_cbp(s, block, motion_x, motion_y); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1276 |
1789 | 1277 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) { |
324 | 1278 /* skip macroblock */ |
1279 put_bits(&s->pb, 1, 1); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1280 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1281 s->misc_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1282 s->last_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1283 } |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
1284 s->skip_count++; |
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
1285 |
324 | 1286 return; |
1287 } | |
2979 | 1288 put_bits(&s->pb, 1, 0); /* mb coded */ |
2967 | 1289 |
324 | 1290 cbpc = cbp & 3; |
1637 | 1291 cbpy = cbp >> 2; |
1292 if(s->alt_inter_vlc==0 || cbpc!=3) | |
1293 cbpy ^= 0xF; | |
695 | 1294 if(s->dquant) cbpc+= 8; |
1633 | 1295 if(s->mv_type==MV_TYPE_16X16){ |
1296 put_bits(&s->pb, | |
1297 inter_MCBPC_bits[cbpc], | |
1298 inter_MCBPC_code[cbpc]); | |
1299 | |
1300 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1301 if(s->dquant) | |
1302 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
2967 | 1303 |
1633 | 1304 if(interleaved_stats){ |
1305 s->misc_bits+= get_bits_diff(s); | |
1306 } | |
1307 | |
1308 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1309 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1310 |
1311 if (!s->umvplus) { | |
2502 | 1312 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1313 motion_y - pred_y, 1); | |
1633 | 1314 } |
1315 else { | |
1316 h263p_encode_umotion(s, motion_x - pred_x); | |
1317 h263p_encode_umotion(s, motion_y - pred_y); | |
1318 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1319 /* To prevent Start Code emulation */ | |
1320 put_bits(&s->pb,1,1); | |
1321 } | |
1322 }else{ | |
1323 put_bits(&s->pb, | |
1324 inter_MCBPC_bits[cbpc+16], | |
1325 inter_MCBPC_code[cbpc+16]); | |
1326 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1327 if(s->dquant) | |
1328 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1329 | |
1330 if(interleaved_stats){ | |
1331 s->misc_bits+= get_bits_diff(s); | |
1332 } | |
1333 | |
1334 for(i=0; i<4; i++){ | |
1335 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1336 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 1337 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1338 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1339 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
2967 | 1340 if (!s->umvplus) { |
2502 | 1341 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1342 motion_y - pred_y, 1); | |
1633 | 1343 } |
1344 else { | |
1345 h263p_encode_umotion(s, motion_x - pred_x); | |
1346 h263p_encode_umotion(s, motion_y - pred_y); | |
1347 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1348 /* To prevent Start Code emulation */ | |
1349 put_bits(&s->pb,1,1); | |
1350 } | |
1351 } | |
324 | 1352 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1353 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1354 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1355 s->mv_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1356 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1357 } else { |
1639 | 1358 assert(s->mb_intra); |
2967 | 1359 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1360 cbp = 0; |
1666 | 1361 if (s->h263_aic) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1362 /* Predict DC */ |
1666 | 1363 for(i=0; i<6; i++) { |
1064 | 1364 int16_t level = block[i][0]; |
1666 | 1365 int scale; |
2967 | 1366 |
1666 | 1367 if(i<4) scale= s->y_dc_scale; |
1368 else scale= s->c_dc_scale; | |
1369 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1370 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1371 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1372 /* Quant */ |
1666 | 1373 if (level >= 0) |
1374 level = (level + (scale>>1))/scale; | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1375 else |
1666 | 1376 level = (level - (scale>>1))/scale; |
2967 | 1377 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1378 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1379 if (level == 0 && s->block_last_index[i] == 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1380 s->block_last_index[i] = -1; |
1666 | 1381 |
1382 if(!s->modified_quant){ | |
1383 if (level < -127) | |
1384 level = -127; | |
1385 else if (level > 127) | |
1386 level = 127; | |
1387 } | |
1388 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1389 block[i][0] = level; |
2967 | 1390 /* Reconstruction */ |
1666 | 1391 rec_intradc[i] = scale*level + pred_dc; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1392 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1393 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1394 //if ((rec_intradc[i] % 2) == 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1395 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1396 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1397 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1398 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1399 else if (rec_intradc[i] > 2047) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1400 rec_intradc[i] = 2047; |
2967 | 1401 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1402 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1403 *dc_ptr[i] = rec_intradc[i]; |
1666 | 1404 if (s->block_last_index[i] >= 0) |
1405 cbp |= 1 << (5 - i); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1406 } |
1666 | 1407 }else{ |
1408 for(i=0; i<6; i++) { | |
1409 /* compute cbp */ | |
1410 if (s->block_last_index[i] >= 1) | |
1411 cbp |= 1 << (5 - i); | |
1412 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1413 } |
0 | 1414 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1415 cbpc = cbp & 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1416 if (s->pict_type == I_TYPE) { |
695 | 1417 if(s->dquant) cbpc+=4; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1418 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1419 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1420 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1421 } else { |
695 | 1422 if(s->dquant) cbpc+=8; |
2979 | 1423 put_bits(&s->pb, 1, 0); /* mb coded */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1424 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1425 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1426 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1427 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1428 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1429 /* XXX: currently, we do not try to use ac prediction */ |
2979 | 1430 put_bits(&s->pb, 1, 0); /* no AC prediction */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1431 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1432 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1433 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 1434 if(s->dquant) |
1435 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1436 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1437 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1438 s->misc_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1439 } |
0 | 1440 } |
1441 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1442 for(i=0; i<6; i++) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1443 /* encode each block */ |
1354 | 1444 h263_encode_block(s, block[i], i); |
2967 | 1445 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1446 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1447 if (s->h263_aic && s->mb_intra) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1448 block[i][0] = rec_intradc[i]; |
2967 | 1449 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1450 } |
0 | 1451 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1452 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1453 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1454 if (!s->mb_intra) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1455 s->p_tex_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1456 s->f_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1457 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1458 s->i_tex_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1459 s->i_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1460 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1461 } |
0 | 1462 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1463 #endif |
0 | 1464 |
1656 | 1465 void ff_h263_loop_filter(MpegEncContext * s){ |
1644 | 1466 int qp_c; |
1467 const int linesize = s->linesize; | |
1468 const int uvlinesize= s->uvlinesize; | |
1469 const int xy = s->mb_y * s->mb_stride + s->mb_x; | |
1470 uint8_t *dest_y = s->dest[0]; | |
1471 uint8_t *dest_cb= s->dest[1]; | |
1472 uint8_t *dest_cr= s->dest[2]; | |
2967 | 1473 |
1644 | 1474 // if(s->pict_type==B_TYPE && !s->readable) return; |
1475 | |
1476 /* | |
1477 Diag Top | |
1478 Left Center | |
1479 */ | |
1480 if(!IS_SKIP(s->current_picture.mb_type[xy])){ | |
1481 qp_c= s->qscale; | |
1482 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c); | |
1483 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1484 }else | |
1485 qp_c= 0; | |
1486 | |
1487 if(s->mb_y){ | |
1488 int qp_dt, qp_t, qp_tc; | |
1489 | |
1490 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride])) | |
1491 qp_t=0; | |
2967 | 1492 else |
1644 | 1493 qp_t= s->current_picture.qscale_table[xy-s->mb_stride]; |
1494 | |
2967 | 1495 if(qp_c) |
1644 | 1496 qp_tc= qp_c; |
1497 else | |
1498 qp_tc= qp_t; | |
2967 | 1499 |
1644 | 1500 if(qp_tc){ |
1501 const int chroma_qp= s->chroma_qscale_table[qp_tc]; | |
1502 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); | |
1503 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc); | |
2967 | 1504 |
1644 | 1505 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); |
1506 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1507 } | |
2967 | 1508 |
1644 | 1509 if(qp_t) |
1510 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t); | |
2967 | 1511 |
1644 | 1512 if(s->mb_x){ |
1513 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride])) | |
1514 qp_dt= qp_t; | |
1515 else | |
1516 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride]; | |
2967 | 1517 |
1644 | 1518 if(qp_dt){ |
1519 const int chroma_qp= s->chroma_qscale_table[qp_dt]; | |
1520 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt); | |
1521 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp); | |
2178 | 1522 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp); |
1644 | 1523 } |
1524 } | |
1525 } | |
1526 | |
1527 if(qp_c){ | |
1528 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c); | |
1529 if(s->mb_y + 1 == s->mb_height) | |
1530 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1531 } | |
2967 | 1532 |
1644 | 1533 if(s->mb_x){ |
1534 int qp_lc; | |
1535 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1])) | |
1536 qp_lc= qp_c; | |
1537 else | |
1538 qp_lc= s->current_picture.qscale_table[xy-1]; | |
2967 | 1539 |
1644 | 1540 if(qp_lc){ |
1541 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); | |
1542 if(s->mb_y + 1 == s->mb_height){ | |
1543 const int chroma_qp= s->chroma_qscale_table[qp_lc]; | |
1544 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc); | |
1545 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); | |
1546 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1547 } | |
1548 } | |
1549 } | |
1550 } | |
1551 | |
3777 | 1552 #ifdef CONFIG_ENCODERS |
3781 | 1553 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1554 { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1555 int x, y, wrap, a, c, pred_dc, scale; |
3781 | 1556 int16_t *dc_val; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1557 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1558 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1559 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1560 x = 2 * s->mb_x + (n & 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1561 y = 2 * s->mb_y + ((n & 2) >> 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1562 wrap = s->b8_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1563 dc_val = s->dc_val[0]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1564 scale = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1565 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1566 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1567 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1568 wrap = s->mb_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1569 dc_val = s->dc_val[n - 4 + 1]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1570 scale = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1571 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1572 /* B C |
2967 | 1573 * A X |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1574 */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1575 a = dc_val[(x - 1) + (y) * wrap]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1576 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1577 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1578 /* No prediction outside GOB boundary */ |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1579 if(s->first_slice_line && n!=3){ |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1580 if(n!=2) c= 1024; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1581 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1582 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1583 pred_dc = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1584 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1585 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1586 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1587 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1588 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1589 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1590 pred_dc = c; |
2967 | 1591 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1592 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1593 //pred_dc = (pred_dc + (scale >> 1)) / scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1594 *dc_val_ptr = &dc_val[x + y * wrap]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1595 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1596 } |
3777 | 1597 #endif /* CONFIG_ENCODERS */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1598 |
1057 | 1599 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n) |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1600 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1601 int x, y, wrap, a, c, pred_dc, scale, i; |
3781 | 1602 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1603 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1604 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1605 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1606 x = 2 * s->mb_x + (n & 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1607 y = 2 * s->mb_y + (n>> 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1608 wrap = s->b8_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1609 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1610 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1611 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1612 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1613 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1614 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1615 wrap = s->mb_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1616 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1617 ac_val = s->ac_val[n - 4 + 1][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1618 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1619 } |
2967 | 1620 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1621 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1622 ac_val1 = ac_val; |
2967 | 1623 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1624 /* B C |
2967 | 1625 * A X |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1626 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1627 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1628 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1629 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1630 /* No prediction outside GOB boundary */ |
1639 | 1631 if(s->first_slice_line && n!=3){ |
1632 if(n!=2) c= 1024; | |
1633 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; | |
1634 } | |
2967 | 1635 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1636 if (s->ac_pred) { |
1639 | 1637 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1638 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1639 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1640 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1641 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1642 for(i=1;i<8;i++) { |
1092 | 1643 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1644 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1645 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1646 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1647 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1648 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1649 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1650 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1651 for(i=1;i<8;i++) { |
1092 | 1652 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1653 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1654 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1655 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1656 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1657 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1658 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1659 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1660 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1661 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1662 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1663 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1664 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1665 } |
2967 | 1666 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1667 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1668 block[0]=block[0]*scale + pred_dc; |
2967 | 1669 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1670 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1671 block[0] = 0; |
2967 | 1672 else |
1639 | 1673 block[0] |= 1; |
2967 | 1674 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1675 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1676 dc_val[(x) + (y) * wrap] = block[0]; |
2967 | 1677 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1678 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1679 for(i=1;i<8;i++) |
1092 | 1680 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1681 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1682 for(i=1;i<8;i++) |
1092 | 1683 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1684 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1685 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1686 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir, |
0 | 1687 int *px, int *py) |
1688 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1689 int wrap; |
1655 | 1690 int16_t *A, *B, *C, (*mot_val)[2]; |
1691 static const int off[4]= {2, 1, 1, -1}; | |
1692 | |
1693 wrap = s->b8_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1694 mot_val = s->current_picture.motion_val[dir] + s->block_index[block]; |
1655 | 1695 |
1696 A = mot_val[ - 1]; | |
1697 /* special case for first (slice) line */ | |
1698 if (s->first_slice_line && block<3) { | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
1699 // we can't just change some MVs to simulate that as we need them for the B frames (and ME) |
1655 | 1700 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( |
1701 if(block==0){ //most common case | |
1702 if(s->mb_x == s->resync_mb_x){ //rare | |
1703 *px= *py = 0; | |
1704 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1705 C = mot_val[off[block] - wrap]; | |
1706 if(s->mb_x==0){ | |
1707 *px = C[0]; | |
1708 *py = C[1]; | |
1709 }else{ | |
1710 *px = mid_pred(A[0], 0, C[0]); | |
1711 *py = mid_pred(A[1], 0, C[1]); | |
1712 } | |
1713 }else{ | |
1714 *px = A[0]; | |
1715 *py = A[1]; | |
1716 } | |
1717 }else if(block==1){ | |
1718 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1719 C = mot_val[off[block] - wrap]; | |
1720 *px = mid_pred(A[0], 0, C[0]); | |
1721 *py = mid_pred(A[1], 0, C[1]); | |
1722 }else{ | |
1723 *px = A[0]; | |
1724 *py = A[1]; | |
1725 } | |
1726 }else{ /* block==2*/ | |
1727 B = mot_val[ - wrap]; | |
1728 C = mot_val[off[block] - wrap]; | |
1729 if(s->mb_x == s->resync_mb_x) //rare | |
1730 A[0]=A[1]=0; | |
2967 | 1731 |
1655 | 1732 *px = mid_pred(A[0], B[0], C[0]); |
1733 *py = mid_pred(A[1], B[1], C[1]); | |
1734 } | |
1735 } else { | |
1736 B = mot_val[ - wrap]; | |
1737 C = mot_val[off[block] - wrap]; | |
1738 *px = mid_pred(A[0], B[0], C[0]); | |
1739 *py = mid_pred(A[1], B[1], C[1]); | |
1740 } | |
1741 return *mot_val; | |
1742 } | |
1743 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1744 #ifdef CONFIG_ENCODERS |
2017 | 1745 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1746 { |
702 | 1747 int range, l, bit_size, sign, code, bits; |
0 | 1748 |
1749 if (val == 0) { | |
1750 /* zero vector */ | |
1751 code = 0; | |
1752 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1753 } else { | |
324 | 1754 bit_size = f_code - 1; |
0 | 1755 range = 1 << bit_size; |
1756 /* modulo encoding */ | |
2093 | 1757 l= INT_BIT - 6 - bit_size; |
1758 val = (val<<l)>>l; | |
702 | 1759 sign = val>>31; |
1760 val= (val^sign)-sign; | |
1761 sign&=1; | |
2093 | 1762 |
312 | 1763 val--; |
1764 code = (val >> bit_size) + 1; | |
1765 bits = val & (range - 1); | |
0 | 1766 |
2967 | 1767 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); |
0 | 1768 if (bit_size > 0) { |
1769 put_bits(&s->pb, bit_size, bits); | |
1770 } | |
1771 } | |
1772 } | |
1773 | |
78 | 1774 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1775 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1776 { | |
2967 | 1777 short sval = 0; |
78 | 1778 short i = 0; |
1779 short n_bits = 0; | |
1780 short temp_val; | |
1781 int code = 0; | |
1782 int tcode; | |
2967 | 1783 |
78 | 1784 if ( val == 0) |
1785 put_bits(&s->pb, 1, 1); | |
1786 else if (val == 1) | |
1787 put_bits(&s->pb, 3, 0); | |
1788 else if (val == -1) | |
1789 put_bits(&s->pb, 3, 2); | |
1790 else { | |
2967 | 1791 |
78 | 1792 sval = ((val < 0) ? (short)(-val):(short)val); |
1793 temp_val = sval; | |
2967 | 1794 |
78 | 1795 while (temp_val != 0) { |
1796 temp_val = temp_val >> 1; | |
1797 n_bits++; | |
1798 } | |
2967 | 1799 |
78 | 1800 i = n_bits - 1; |
1801 while (i > 0) { | |
1802 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1803 tcode = (tcode << 1) | 1; | |
1804 code = (code << 2) | tcode; | |
1805 i--; | |
1806 } | |
1807 code = ((code << 1) | (val < 0)) << 1; | |
1808 put_bits(&s->pb, (2*n_bits)+1, code); | |
1809 //printf("\nVal = %d\tCode = %d", sval, code); | |
1810 } | |
1811 } | |
1812 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1813 static void init_mv_penalty_and_fcode(MpegEncContext *s) |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1814 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1815 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1816 int mv; |
2967 | 1817 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1818 for(f_code=1; f_code<=MAX_FCODE; f_code++){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1819 for(mv=-MAX_MV; mv<=MAX_MV; mv++){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1820 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1821 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1822 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1823 else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1824 int val, bit_size, range, code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1825 |
1893
779bdf5063ce
1000000l (using uninitalized variable for initalizing bits per MV table)
michael
parents:
1873
diff
changeset
|
1826 bit_size = f_code - 1; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1827 range = 1 << bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1828 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1829 val=mv; |
2967 | 1830 if (val < 0) |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1831 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1832 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1833 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1834 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1835 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1836 }else{ |
2985 | 1837 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1838 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1839 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1840 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1841 mv_penalty[f_code][mv+MAX_MV]= len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1842 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1843 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1844 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1845 for(f_code=MAX_FCODE; f_code>0; f_code--){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1846 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1847 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1848 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1849 } |
287 | 1850 |
1851 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1852 umv_fcode_tab[mv]= 1; | |
1853 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1854 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1855 #endif |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1856 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
1857 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
1858 |
468 | 1859 static void init_uni_dc_tab(void) |
293 | 1860 { |
1861 int level, uni_code, uni_len; | |
1862 | |
312 | 1863 for(level=-256; level<256; level++){ |
293 | 1864 int size, v, l; |
1865 /* find number of bits */ | |
1866 size = 0; | |
1867 v = abs(level); | |
1868 while (v) { | |
1869 v >>= 1; | |
2979 | 1870 size++; |
293 | 1871 } |
1872 | |
1873 if (level < 0) | |
1874 l= (-level) ^ ((1 << size) - 1); | |
1875 else | |
1876 l= level; | |
1877 | |
1878 /* luminance */ | |
1879 uni_code= DCtab_lum[size][0]; | |
1880 uni_len = DCtab_lum[size][1]; | |
1881 | |
1882 if (size > 0) { | |
1883 uni_code<<=size; uni_code|=l; | |
1884 uni_len+=size; | |
1885 if (size > 8){ | |
1886 uni_code<<=1; uni_code|=1; | |
1887 uni_len++; | |
1888 } | |
1889 } | |
1013 | 1890 uni_DCtab_lum_bits[level+256]= uni_code; |
1891 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1892 |
1893 /* chrominance */ | |
1894 uni_code= DCtab_chrom[size][0]; | |
1895 uni_len = DCtab_chrom[size][1]; | |
2967 | 1896 |
293 | 1897 if (size > 0) { |
1898 uni_code<<=size; uni_code|=l; | |
1899 uni_len+=size; | |
1900 if (size > 8){ | |
1901 uni_code<<=1; uni_code|=1; | |
1902 uni_len++; | |
1903 } | |
1904 } | |
1013 | 1905 uni_DCtab_chrom_bits[level+256]= uni_code; |
1906 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1907 |
1908 } | |
1909 } | |
1910 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
1911 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
1912 |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1913 #ifdef CONFIG_ENCODERS |
1064 | 1914 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1915 int slevel, run, last; |
2967 | 1916 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1917 assert(MAX_LEVEL >= 64); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1918 assert(MAX_RUN >= 63); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1919 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1920 for(slevel=-64; slevel<64; slevel++){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1921 if(slevel==0) continue; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1922 for(run=0; run<64; run++){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1923 for(last=0; last<=1; last++){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1924 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1925 int level= slevel < 0 ? -slevel : slevel; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1926 int sign= slevel < 0 ? 1 : 0; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1927 int bits, len, code; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1928 int level1, run1; |
2967 | 1929 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1930 len_tab[index]= 100; |
2967 | 1931 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1932 /* ESC0 */ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1933 code= get_rl_index(rl, last, run, level); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1934 bits= rl->table_vlc[code][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1935 len= rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1936 bits=bits*2+sign; len++; |
2967 | 1937 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1938 if(code!=rl->n && len < len_tab[index]){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1939 bits_tab[index]= bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1940 len_tab [index]= len; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1941 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1942 #if 1 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1943 /* ESC1 */ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1944 bits= rl->table_vlc[rl->n][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1945 len= rl->table_vlc[rl->n][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1946 bits=bits*2; len++; //esc1 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1947 level1= level - rl->max_level[last][run]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1948 if(level1>0){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1949 code= get_rl_index(rl, last, run, level1); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1950 bits<<= rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1951 len += rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1952 bits += rl->table_vlc[code][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1953 bits=bits*2+sign; len++; |
2967 | 1954 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1955 if(code!=rl->n && len < len_tab[index]){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1956 bits_tab[index]= bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1957 len_tab [index]= len; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1958 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1959 } |
2967 | 1960 #endif |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1961 #if 1 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1962 /* ESC2 */ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1963 bits= rl->table_vlc[rl->n][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1964 len= rl->table_vlc[rl->n][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1965 bits=bits*4+2; len+=2; //esc2 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1966 run1 = run - rl->max_run[last][level] - 1; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1967 if(run1>=0){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1968 code= get_rl_index(rl, last, run1, level); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1969 bits<<= rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1970 len += rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1971 bits += rl->table_vlc[code][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1972 bits=bits*2+sign; len++; |
2967 | 1973 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1974 if(code!=rl->n && len < len_tab[index]){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1975 bits_tab[index]= bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1976 len_tab [index]= len; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1977 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1978 } |
2967 | 1979 #endif |
1980 /* ESC3 */ | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1981 bits= rl->table_vlc[rl->n][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1982 len = rl->table_vlc[rl->n][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1983 bits=bits*4+3; len+=2; //esc3 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1984 bits=bits*2+last; len++; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1985 bits=bits*64+run; len+=6; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1986 bits=bits*2+1; len++; //marker |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1987 bits=bits*4096+(slevel&0xfff); len+=12; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1988 bits=bits*2+1; len++; //marker |
2967 | 1989 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1990 if(len < len_tab[index]){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1991 bits_tab[index]= bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1992 len_tab [index]= len; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1993 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1994 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1995 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1996 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1997 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1998 |
2253 | 1999 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
2000 int slevel, run, last; | |
2967 | 2001 |
2253 | 2002 assert(MAX_LEVEL >= 64); |
2003 assert(MAX_RUN >= 63); | |
2004 | |
2005 for(slevel=-64; slevel<64; slevel++){ | |
2006 if(slevel==0) continue; | |
2007 for(run=0; run<64; run++){ | |
2008 for(last=0; last<=1; last++){ | |
2009 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); | |
2010 int level= slevel < 0 ? -slevel : slevel; | |
2011 int sign= slevel < 0 ? 1 : 0; | |
2012 int bits, len, code; | |
2967 | 2013 |
2253 | 2014 len_tab[index]= 100; |
2967 | 2015 |
2253 | 2016 /* ESC0 */ |
2017 code= get_rl_index(rl, last, run, level); | |
2018 bits= rl->table_vlc[code][0]; | |
2019 len= rl->table_vlc[code][1]; | |
2020 bits=bits*2+sign; len++; | |
2967 | 2021 |
2253 | 2022 if(code!=rl->n && len < len_tab[index]){ |
2023 if(bits_tab) bits_tab[index]= bits; | |
2024 len_tab [index]= len; | |
2025 } | |
2026 /* ESC */ | |
2027 bits= rl->table_vlc[rl->n][0]; | |
2028 len = rl->table_vlc[rl->n][1]; | |
2029 bits=bits*2+last; len++; | |
2030 bits=bits*64+run; len+=6; | |
2031 bits=bits*256+(level&0xff); len+=8; | |
2967 | 2032 |
2253 | 2033 if(len < len_tab[index]){ |
2034 if(bits_tab) bits_tab[index]= bits; | |
2035 len_tab [index]= len; | |
2036 } | |
2037 } | |
2038 } | |
2039 } | |
2040 } | |
2041 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2042 void h263_encode_init(MpegEncContext *s) |
0 | 2043 { |
2044 static int done = 0; | |
2045 | |
2046 if (!done) { | |
2047 done = 1; | |
293 | 2048 |
2049 init_uni_dc_tab(); | |
2050 | |
4668 | 2051 init_rl(&rl_inter, static_rl_table_store[0]); |
2052 init_rl(&rl_intra, static_rl_table_store[1]); | |
2053 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
2967 | 2054 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2055 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2056 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len); |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2057 |
2253 | 2058 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); |
2059 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len); | |
2060 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2061 init_mv_penalty_and_fcode(s); |
0 | 2062 } |
936 | 2063 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p |
2967 | 2064 |
2253 | 2065 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len; |
2066 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; | |
2067 if(s->h263_aic){ | |
2068 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len; | |
2069 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; | |
2070 } | |
2071 s->ac_esc_length= 7+1+6+8; | |
2072 | |
287 | 2073 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 2074 switch(s->codec_id){ |
2075 case CODEC_ID_MPEG4: | |
2076 s->fcode_tab= fcode_tab; | |
2077 s->min_qcoeff= -2048; | |
2078 s->max_qcoeff= 2047; | |
945 | 2079 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
2080 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
2081 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
2082 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 2083 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
2084 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 2085 s->ac_esc_length= 7+2+1+6+1+12+1; |
1799 | 2086 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; |
2087 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
2088 | |
1424 | 2089 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ |
1483 | 2090 |
1424 | 2091 s->avctx->extradata= av_malloc(1024); |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1521
diff
changeset
|
2092 init_put_bits(&s->pb, s->avctx->extradata, 1024); |
2967 | 2093 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2094 if(!(s->workaround_bugs & FF_BUG_MS)) |
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2095 mpeg4_encode_visual_object_header(s); |
1424 | 2096 mpeg4_encode_vol_header(s, 0, 0); |
2097 | |
2098 // ff_mpeg4_stuffing(&s->pb); ? | |
2099 flush_put_bits(&s->pb); | |
1786 | 2100 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3; |
1424 | 2101 } |
2967 | 2102 |
344 | 2103 break; |
2104 case CODEC_ID_H263P: | |
1666 | 2105 if(s->umvplus) |
2106 s->fcode_tab= umv_fcode_tab; | |
2107 if(s->modified_quant){ | |
2108 s->min_qcoeff= -2047; | |
2109 s->max_qcoeff= 2047; | |
2110 }else{ | |
2111 s->min_qcoeff= -127; | |
2112 s->max_qcoeff= 127; | |
2113 } | |
344 | 2114 break; |
2967 | 2115 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2116 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2117 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2118 s->min_qcoeff= -1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2119 s->max_qcoeff= 1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2120 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2121 s->min_qcoeff= -127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2122 s->max_qcoeff= 127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2123 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2124 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2125 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2126 break; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2127 default: //nothing needed - default table already set in mpegvideo.c |
1089 | 2128 s->min_qcoeff= -127; |
344 | 2129 s->max_qcoeff= 127; |
498 | 2130 s->y_dc_scale_table= |
2131 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 2132 } |
0 | 2133 } |
2134 | |
1034 | 2135 /** |
2136 * encodes a 8x8 block. | |
2137 * @param block the 8x8 block | |
2138 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2139 */ | |
0 | 2140 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
2141 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2142 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2143 RLTable *rl; |
0 | 2144 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2145 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2146 if (s->mb_intra && !s->h263_aic) { |
231 | 2147 /* DC coef */ |
1089 | 2148 level = block[0]; |
0 | 2149 /* 255 cannot be represented, so we clamp */ |
2150 if (level > 254) { | |
2151 level = 254; | |
2152 block[0] = 254; | |
2153 } | |
231 | 2154 /* 0 cannot be represented also */ |
1089 | 2155 else if (level < 1) { |
231 | 2156 level = 1; |
2157 block[0] = 1; | |
2158 } | |
1090 | 2159 if (level == 128) //FIXME check rv10 |
1089 | 2160 put_bits(&s->pb, 8, 0xff); |
2161 else | |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
2162 put_bits(&s->pb, 8, level); |
1089 | 2163 i = 1; |
0 | 2164 } else { |
1089 | 2165 i = 0; |
2166 if (s->h263_aic && s->mb_intra) | |
2167 rl = &rl_intra_aic; | |
2967 | 2168 |
1637 | 2169 if(s->alt_inter_vlc && !s->mb_intra){ |
2170 int aic_vlc_bits=0; | |
2171 int inter_vlc_bits=0; | |
2172 int wrong_pos=-1; | |
2173 int aic_code; | |
2967 | 2174 |
1637 | 2175 last_index = s->block_last_index[n]; |
2176 last_non_zero = i - 1; | |
2177 for (; i <= last_index; i++) { | |
2178 j = s->intra_scantable.permutated[i]; | |
2179 level = block[j]; | |
2180 if (level) { | |
2181 run = i - last_non_zero - 1; | |
2182 last = (i == last_index); | |
2967 | 2183 |
1663 | 2184 if(level<0) level= -level; |
2967 | 2185 |
1637 | 2186 code = get_rl_index(rl, last, run, level); |
2187 aic_code = get_rl_index(&rl_intra_aic, last, run, level); | |
2188 inter_vlc_bits += rl->table_vlc[code][1]+1; | |
2189 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; | |
2190 | |
2191 if (code == rl->n) { | |
1663 | 2192 inter_vlc_bits += 1+6+8-1; |
2967 | 2193 } |
1637 | 2194 if (aic_code == rl_intra_aic.n) { |
1663 | 2195 aic_vlc_bits += 1+6+8-1; |
1637 | 2196 wrong_pos += run + 1; |
2197 }else | |
2198 wrong_pos += wrong_run[aic_code]; | |
2199 last_non_zero = i; | |
2967 | 2200 } |
1637 | 2201 } |
2202 i = 0; | |
2203 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) | |
2204 rl = &rl_intra_aic; | |
2205 } | |
0 | 2206 } |
2967 | 2207 |
0 | 2208 /* AC coefs */ |
2209 last_index = s->block_last_index[n]; | |
2210 last_non_zero = i - 1; | |
2211 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
2212 j = s->intra_scantable.permutated[i]; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2213 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2214 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2215 run = i - last_non_zero - 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2216 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2217 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2218 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2219 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2220 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2221 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2222 } |
0 | 2223 code = get_rl_index(rl, last, run, level); |
2224 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2225 if (code == rl->n) { | |
1354 | 2226 if(s->h263_flv <= 1){ |
0 | 2227 put_bits(&s->pb, 1, last); |
2228 put_bits(&s->pb, 6, run); | |
2967 | 2229 |
1089 | 2230 assert(slevel != 0); |
2231 | |
2967 | 2232 if(level < 128) |
1089 | 2233 put_bits(&s->pb, 8, slevel & 0xff); |
2234 else{ | |
2235 put_bits(&s->pb, 8, 128); | |
2236 put_bits(&s->pb, 5, slevel & 0x1f); | |
2237 put_bits(&s->pb, 6, (slevel>>5)&0x3f); | |
2238 } | |
1354 | 2239 }else{ |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
2240 if(level < 64) { // 7-bit level |
1354 | 2241 put_bits(&s->pb, 1, 0); |
2242 put_bits(&s->pb, 1, last); | |
2243 put_bits(&s->pb, 6, run); | |
2244 | |
2245 put_bits(&s->pb, 7, slevel & 0x7f); | |
2246 } else { | |
2247 /* 11-bit level */ | |
2248 put_bits(&s->pb, 1, 1); | |
2249 put_bits(&s->pb, 1, last); | |
2250 put_bits(&s->pb, 6, run); | |
2251 | |
2252 put_bits(&s->pb, 11, slevel & 0x7ff); | |
2253 } | |
2254 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2255 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2256 put_bits(&s->pb, 1, sign); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2257 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2258 last_non_zero = i; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2259 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2260 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2261 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2262 #endif |
0 | 2263 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
2264 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
2265 |
0 | 2266 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2267 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2268 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2269 */ |
453 | 2270 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 2271 { |
2272 int length; | |
2273 put_bits(pbc, 1, 0); | |
1786 | 2274 length= (-put_bits_count(pbc))&7; |
453 | 2275 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 2276 } |
2277 | |
327 | 2278 /* must be called before writing the header */ |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5268
diff
changeset
|
2279 void ff_set_mpeg4_time(MpegEncContext * s){ |
327 | 2280 if(s->pict_type==B_TYPE){ |
3247 | 2281 ff_mpeg4_init_direct_mv(s); |
327 | 2282 }else{ |
2283 s->last_time_base= s->time_base; | |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5268
diff
changeset
|
2284 s->time_base= s->time/s->avctx->time_base.den; |
327 | 2285 } |
2286 } | |
2287 | |
942 | 2288 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
2289 int hours, minutes, seconds; | |
1763
951403db901f
first coded vs. first displayed pts (segfault & pts fix if b frames are used)
michael
parents:
1760
diff
changeset
|
2290 int64_t time; |
2967 | 2291 |
942 | 2292 put_bits(&s->pb, 16, 0); |
2293 put_bits(&s->pb, 16, GOP_STARTCODE); | |
2967 | 2294 |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2295 time= s->current_picture_ptr->pts; |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2296 if(s->reordered_input_picture[1]) |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2297 time= FFMIN(time, s->reordered_input_picture[1]->pts); |
2637 | 2298 time= time*s->avctx->time_base.num; |
2299 | |
2300 seconds= time/s->avctx->time_base.den; | |
942 | 2301 minutes= seconds/60; seconds %= 60; |
2302 hours= minutes/60; minutes %= 60; | |
2303 hours%=24; | |
2304 | |
2305 put_bits(&s->pb, 5, hours); | |
2306 put_bits(&s->pb, 6, minutes); | |
2307 put_bits(&s->pb, 1, 1); | |
2308 put_bits(&s->pb, 6, seconds); | |
2967 | 2309 |
2310 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); | |
942 | 2311 put_bits(&s->pb, 1, 0); //broken link == NO |
2967 | 2312 |
2313 s->last_time_base= time / s->avctx->time_base.den; | |
942 | 2314 |
2315 ff_mpeg4_stuffing(&s->pb); | |
2316 } | |
2317 | |
2318 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
2319 int profile_and_level_indication; | |
2320 int vo_ver_id; | |
2967 | 2321 |
2167 | 2322 if(s->avctx->profile != FF_PROFILE_UNKNOWN){ |
2323 profile_and_level_indication = s->avctx->profile << 4; | |
2324 }else if(s->max_b_frames || s->quarter_sample){ | |
2325 profile_and_level_indication= 0xF0; // adv simple | |
2326 }else{ | |
2327 profile_and_level_indication= 0x00; // simple | |
2328 } | |
2329 | |
2330 if(s->avctx->level != FF_LEVEL_UNKNOWN){ | |
2331 profile_and_level_indication |= s->avctx->level; | |
2332 }else{ | |
2333 profile_and_level_indication |= 1; //level 1 | |
2334 } | |
2335 | |
2336 if(profile_and_level_indication>>4 == 0xF){ | |
942 | 2337 vo_ver_id= 5; |
2338 }else{ | |
2339 vo_ver_id= 1; | |
2340 } | |
2167 | 2341 |
942 | 2342 //FIXME levels |
2343 | |
2344 put_bits(&s->pb, 16, 0); | |
2345 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2346 |
942 | 2347 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2348 |
942 | 2349 put_bits(&s->pb, 16, 0); |
2350 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
2967 | 2351 |
942 | 2352 put_bits(&s->pb, 1, 1); |
2353 put_bits(&s->pb, 4, vo_ver_id); | |
2354 put_bits(&s->pb, 3, 1); //priority | |
2967 | 2355 |
942 | 2356 put_bits(&s->pb, 4, 1); //visual obj type== video obj |
2967 | 2357 |
942 | 2358 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME |
2359 | |
2360 ff_mpeg4_stuffing(&s->pb); | |
2361 } | |
2362 | |
2363 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 2364 { |
942 | 2365 int vo_ver_id; |
336 | 2366 |
5275
91416b4f1929
Better place to disable some mpeg4 code and ensure that
aurel
parents:
5274
diff
changeset
|
2367 if (!ENABLE_MPEG4_ENCODER) return; |
91416b4f1929
Better place to disable some mpeg4 code and ensure that
aurel
parents:
5274
diff
changeset
|
2368 |
942 | 2369 if(s->max_b_frames || s->quarter_sample){ |
2370 vo_ver_id= 5; | |
923 | 2371 s->vo_type= ADV_SIMPLE_VO_TYPE; |
2372 }else{ | |
942 | 2373 vo_ver_id= 1; |
923 | 2374 s->vo_type= SIMPLE_VO_TYPE; |
2375 } | |
336 | 2376 |
263 | 2377 put_bits(&s->pb, 16, 0); |
942 | 2378 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 2379 put_bits(&s->pb, 16, 0); |
942 | 2380 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 2381 |
2979 | 2382 put_bits(&s->pb, 1, 0); /* random access vol */ |
2383 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2384 if(s->workaround_bugs & FF_BUG_MS) { |
2979 | 2385 put_bits(&s->pb, 1, 0); /* is obj layer id= no */ |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2386 } else { |
2979 | 2387 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
2388 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
2389 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2390 } |
2967 | 2391 |
1548 | 2392 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 2393 |
2394 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
1548 | 2395 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
2396 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
2397 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
2398 } |
336 | 2399 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2400 if(s->workaround_bugs & FF_BUG_MS) { // |
2979 | 2401 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */ |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2402 } else { |
2979 | 2403 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ |
2404 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2405 put_bits(&s->pb, 1, s->low_delay); |
2979 | 2406 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ |
2407 } | |
2408 | |
2409 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ | |
2410 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2967 | 2411 |
2637 | 2412 put_bits(&s->pb, 16, s->avctx->time_base.den); |
263 | 2413 if (s->time_increment_bits < 1) |
2414 s->time_increment_bits = 1; | |
2979 | 2415 put_bits(&s->pb, 1, 1); /* marker bit */ |
2416 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
2417 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2418 put_bits(&s->pb, 13, s->width); /* vol width */ | |
2419 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2420 put_bits(&s->pb, 13, s->height); /* vol height */ | |
2421 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 2422 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
2979 | 2423 put_bits(&s->pb, 1, 1); /* obmc disable */ |
263 | 2424 if (vo_ver_id == 1) { |
2979 | 2425 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ |
942 | 2426 }else{ |
2979 | 2427 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ |
2428 } | |
2429 | |
2430 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ | |
2431 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ | |
1411 | 2432 |
2433 if(s->mpeg_quant){ | |
2434 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
2435 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
2436 } | |
599 | 2437 |
263 | 2438 if (vo_ver_id != 1) |
936 | 2439 put_bits(&s->pb, 1, s->quarter_sample); |
2979 | 2440 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 2441 s->resync_marker= s->rtp_mode; |
2442 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
2443 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
2444 if(s->data_partitioning){ | |
2979 | 2445 put_bits(&s->pb, 1, 0); /* no rvlc */ |
453 | 2446 } |
2447 | |
263 | 2448 if (vo_ver_id != 1){ |
2979 | 2449 put_bits(&s->pb, 1, 0); /* newpred */ |
2450 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
2451 } | |
2452 put_bits(&s->pb, 1, 0); /* scalability */ | |
2967 | 2453 |
453 | 2454 ff_mpeg4_stuffing(&s->pb); |
676 | 2455 |
2456 /* user data */ | |
1092 | 2457 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 2458 put_bits(&s->pb, 16, 0); |
2979 | 2459 put_bits(&s->pb, 16, 0x1B2); /* user_data */ |
2460 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); | |
676 | 2461 } |
263 | 2462 } |
2463 | |
2464 /* write mpeg4 VOP header */ | |
2465 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
2466 { | |
324 | 2467 int time_incr; |
2468 int time_div, time_mod; | |
2967 | 2469 |
453 | 2470 if(s->pict_type==I_TYPE){ |
953 | 2471 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ |
2658
d1609cfeb1d0
#defines for strict_std_compliance and split between inofficial extensions and non standarized things
michael
parents:
2646
diff
changeset
|
2472 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2473 mpeg4_encode_visual_object_header(s); |
2658
d1609cfeb1d0
#defines for strict_std_compliance and split between inofficial extensions and non standarized things
michael
parents:
2646
diff
changeset
|
2474 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2475 mpeg4_encode_vol_header(s, 0, 0); |
942 | 2476 } |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2477 if(!(s->workaround_bugs & FF_BUG_MS)) |
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2478 mpeg4_encode_gop_header(s); |
453 | 2479 } |
2967 | 2480 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2481 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2482 |
2637 | 2483 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE); |
2967 | 2484 |
2979 | 2485 put_bits(&s->pb, 16, 0); /* vop header */ |
2486 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ | |
2487 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | |
324 | 2488 |
2679 | 2489 assert(s->time>=0); |
2637 | 2490 time_div= s->time/s->avctx->time_base.den; |
2491 time_mod= s->time%s->avctx->time_base.den; | |
324 | 2492 time_incr= time_div - s->last_time_base; |
1936
e5b0b33cf8aa
assert(time_incr >= 0) so its clear that this MUST be the case
michael
parents:
1914
diff
changeset
|
2493 assert(time_incr >= 0); |
324 | 2494 while(time_incr--) |
2495 put_bits(&s->pb, 1, 1); | |
2967 | 2496 |
0 | 2497 put_bits(&s->pb, 1, 0); |
2498 | |
2979 | 2499 put_bits(&s->pb, 1, 1); /* marker */ |
2500 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ | |
2501 put_bits(&s->pb, 1, 1); /* marker */ | |
2502 put_bits(&s->pb, 1, 1); /* vop coded */ | |
2967 | 2503 if ( s->pict_type == P_TYPE |
263 | 2504 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { |
2979 | 2505 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
2506 } | |
2507 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 2508 if(!s->progressive_sequence){ |
1659 | 2509 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); |
697 | 2510 put_bits(&s->pb, 1, s->alternate_scan); |
2511 } | |
263 | 2512 //FIXME sprite stuff |
0 | 2513 |
2514 put_bits(&s->pb, 5, s->qscale); | |
2515 | |
2516 if (s->pict_type != I_TYPE) | |
2979 | 2517 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ |
263 | 2518 if (s->pict_type == B_TYPE) |
2979 | 2519 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ |
0 | 2520 // printf("****frame %d\n", picture_number); |
2521 } | |
2522 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
2523 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
2524 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2525 /** |
1034 | 2526 * predicts the dc. |
2003 | 2527 * encoding quantized level -> quantized diff |
2967 | 2528 * decoding quantized diff -> quantized level |
1034 | 2529 * @param n block index (0-3 are luma, 4-5 are chroma) |
2530 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
2531 */ | |
2003 | 2532 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) |
0 | 2533 { |
2003 | 2534 int a, b, c, wrap, pred, scale, ret; |
3781 | 2535 int16_t *dc_val; |
0 | 2536 |
2537 /* find prediction */ | |
2538 if (n < 4) { | |
2979 | 2539 scale = s->y_dc_scale; |
0 | 2540 } else { |
2979 | 2541 scale = s->c_dc_scale; |
0 | 2542 } |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
2543 if(IS_3IV1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
2544 scale= 8; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
2545 |
266 | 2546 wrap= s->block_wrap[n]; |
2547 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 2548 |
2549 /* B C | |
2967 | 2550 * A X |
0 | 2551 */ |
266 | 2552 a = dc_val[ - 1]; |
2553 b = dc_val[ - 1 - wrap]; | |
2554 c = dc_val[ - wrap]; | |
0 | 2555 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2556 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2557 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2558 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2559 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2560 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2561 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2562 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2563 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2564 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2565 |
0 | 2566 if (abs(a - b) < abs(b - c)) { |
2979 | 2567 pred = c; |
0 | 2568 *dir_ptr = 1; /* top */ |
2569 } else { | |
2979 | 2570 pred = a; |
0 | 2571 *dir_ptr = 0; /* left */ |
2572 } | |
2573 /* we assume pred is positive */ | |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
2574 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 2575 |
2003 | 2576 if(encoding){ |
2577 ret = level - pred; | |
2578 }else{ | |
2579 level += pred; | |
2580 ret= level; | |
2581 if(s->error_resilience>=3){ | |
2582 if(level<0){ | |
2583 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
2584 return -1; | |
2585 } | |
2586 if(level*scale > 2048 + scale){ | |
2587 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
2588 return -1; | |
2589 } | |
2590 } | |
2591 } | |
2592 level *=scale; | |
2004 | 2593 if(level&(~2047)){ |
2967 | 2594 if(level<0) |
2004 | 2595 level=0; |
2596 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP)) | |
2597 level=2047; | |
2598 } | |
2003 | 2599 dc_val[0]= level; |
2600 | |
2601 return ret; | |
0 | 2602 } |
2603 | |
1034 | 2604 /** |
2605 * predicts the ac. | |
2606 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2607 * @param dir the ac prediction direction | |
2608 */ | |
1008 | 2609 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 2610 int dir) |
2611 { | |
266 | 2612 int i; |
1064 | 2613 int16_t *ac_val, *ac_val1; |
903 | 2614 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2615 |
2616 /* find prediction */ | |
266 | 2617 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 2618 ac_val1 = ac_val; |
2619 if (s->ac_pred) { | |
2620 if (dir == 0) { | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2621 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 2622 /* left prediction */ |
2623 ac_val -= 16; | |
2967 | 2624 |
903 | 2625 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 2626 /* same qscale */ |
2627 for(i=1;i<8;i++) { | |
1092 | 2628 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 2629 } |
2630 }else{ | |
2631 /* different qscale, we must rescale */ | |
2632 for(i=1;i<8;i++) { | |
1092 | 2633 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 2634 } |
0 | 2635 } |
2636 } else { | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2637 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 2638 /* top prediction */ |
266 | 2639 ac_val -= 16 * s->block_wrap[n]; |
575 | 2640 |
903 | 2641 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 2642 /* same qscale */ |
2643 for(i=1;i<8;i++) { | |
1092 | 2644 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 2645 } |
2646 }else{ | |
2647 /* different qscale, we must rescale */ | |
2648 for(i=1;i<8;i++) { | |
1092 | 2649 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 2650 } |
0 | 2651 } |
2652 } | |
2653 } | |
2654 /* left copy */ | |
2655 for(i=1;i<8;i++) | |
1092 | 2656 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 2657 |
0 | 2658 /* top copy */ |
2659 for(i=1;i<8;i++) | |
1092 | 2660 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 2661 |
0 | 2662 } |
2663 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
2664 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
2665 |
1034 | 2666 /** |
2667 * encodes the dc value. | |
2668 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2669 */ | |
453 | 2670 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2671 { |
293 | 2672 #if 1 |
453 | 2673 // if(level<-255 || level>255) printf("dc overflow\n"); |
293 | 2674 level+=256; |
2675 if (n < 4) { | |
2979 | 2676 /* luminance */ |
2677 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); | |
293 | 2678 } else { |
2979 | 2679 /* chrominance */ |
2680 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); | |
293 | 2681 } |
2682 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2683 int size, v; |
0 | 2684 /* find number of bits */ |
2685 size = 0; | |
2686 v = abs(level); | |
2687 while (v) { | |
2979 | 2688 v >>= 1; |
2689 size++; | |
0 | 2690 } |
2691 | |
2692 if (n < 4) { | |
2979 | 2693 /* luminance */ |
2694 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
0 | 2695 } else { |
2979 | 2696 /* chrominance */ |
2697 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
0 | 2698 } |
2699 | |
2700 /* encode remaining bits */ | |
2701 if (size > 0) { | |
2979 | 2702 if (level < 0) |
2703 level = (-level) ^ ((1 << size) - 1); | |
2704 put_bits(&s->pb, size, level); | |
2705 if (size > 8) | |
2706 put_bits(&s->pb, 1, 1); | |
0 | 2707 } |
293 | 2708 #endif |
0 | 2709 } |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
2710 |
2502 | 2711 static inline int mpeg4_get_dc_length(int level, int n){ |
2712 if (n < 4) { | |
2713 return uni_DCtab_lum_len[level + 256]; | |
2714 } else { | |
2715 return uni_DCtab_chrom_len[level + 256]; | |
2716 } | |
2717 } | |
2718 | |
1034 | 2719 /** |
2720 * encodes a 8x8 block | |
2721 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2722 */ | |
2967 | 2723 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2724 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2725 { |
751 | 2726 int i, last_non_zero; |
2727 #if 0 //variables for the outcommented version | |
2728 int code, sign, last; | |
2729 #endif | |
0 | 2730 const RLTable *rl; |
1064 | 2731 uint32_t *bits_tab; |
2732 uint8_t *len_tab; | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2733 const int last_index = s->block_last_index[n]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2734 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2735 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
2979 | 2736 /* mpeg4 based DC predictor */ |
2737 mpeg4_encode_dc(dc_pb, intra_dc, n); | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2738 if(last_index<1) return; |
2979 | 2739 i = 1; |
0 | 2740 rl = &rl_intra; |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2741 bits_tab= uni_mpeg4_intra_rl_bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2742 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2743 } else { |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2744 if(last_index<0) return; |
2979 | 2745 i = 0; |
0 | 2746 rl = &rl_inter; |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2747 bits_tab= uni_mpeg4_inter_rl_bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2748 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2749 } |
2750 | |
2751 /* AC coefs */ | |
2752 last_non_zero = i - 1; | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2753 #if 1 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2754 for (; i < last_index; i++) { |
2979 | 2755 int level = block[ scan_table[i] ]; |
2756 if (level) { | |
2757 int run = i - last_non_zero - 1; | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2758 level+=64; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2759 if((level&(~127)) == 0){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2760 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2761 put_bits(ac_pb, len_tab[index], bits_tab[index]); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2762 }else{ //ESC3 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2763 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2764 } |
2979 | 2765 last_non_zero = i; |
2766 } | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2767 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2768 /*if(i<=last_index)*/{ |
2979 | 2769 int level = block[ scan_table[i] ]; |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2770 int run = i - last_non_zero - 1; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2771 level+=64; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2772 if((level&(~127)) == 0){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2773 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2774 put_bits(ac_pb, len_tab[index], bits_tab[index]); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2775 }else{ //ESC3 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2776 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2777 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2778 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2779 #else |
0 | 2780 for (; i <= last_index; i++) { |
2979 | 2781 const int slevel = block[ scan_table[i] ]; |
2782 if (slevel) { | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2783 int level; |
2979 | 2784 int run = i - last_non_zero - 1; |
2785 last = (i == last_index); | |
2786 sign = 0; | |
2787 level = slevel; | |
2788 if (level < 0) { | |
2789 sign = 1; | |
2790 level = -level; | |
2791 } | |
0 | 2792 code = get_rl_index(rl, last, run, level); |
453 | 2793 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2794 if (code == rl->n) { |
2795 int level1, run1; | |
2796 level1 = level - rl->max_level[last][run]; | |
2967 | 2797 if (level1 < 1) |
0 | 2798 goto esc2; |
2799 code = get_rl_index(rl, last, run, level1); | |
2800 if (code == rl->n) { | |
2801 esc2: | |
453 | 2802 put_bits(ac_pb, 1, 1); |
0 | 2803 if (level > MAX_LEVEL) |
2804 goto esc3; | |
2805 run1 = run - rl->max_run[last][level] - 1; | |
2806 if (run1 < 0) | |
2807 goto esc3; | |
2808 code = get_rl_index(rl, last, run1, level); | |
2809 if (code == rl->n) { | |
2810 esc3: | |
2811 /* third escape */ | |
453 | 2812 put_bits(ac_pb, 1, 1); |
2813 put_bits(ac_pb, 1, last); | |
2814 put_bits(ac_pb, 6, run); | |
2815 put_bits(ac_pb, 1, 1); | |
2816 put_bits(ac_pb, 12, slevel & 0xfff); | |
2817 put_bits(ac_pb, 1, 1); | |
0 | 2818 } else { |
2819 /* second escape */ | |
453 | 2820 put_bits(ac_pb, 1, 0); |
2821 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2822 put_bits(ac_pb, 1, sign); | |
0 | 2823 } |
2824 } else { | |
2825 /* first escape */ | |
453 | 2826 put_bits(ac_pb, 1, 0); |
2827 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2828 put_bits(ac_pb, 1, sign); | |
0 | 2829 } |
2830 } else { | |
453 | 2831 put_bits(ac_pb, 1, sign); |
0 | 2832 } |
2979 | 2833 last_non_zero = i; |
2834 } | |
0 | 2835 } |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2836 #endif |
0 | 2837 } |
936 | 2838 |
2967 | 2839 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2840 uint8_t *scan_table) |
936 | 2841 { |
2842 int i, last_non_zero; | |
2843 const RLTable *rl; | |
1064 | 2844 uint8_t *len_tab; |
936 | 2845 const int last_index = s->block_last_index[n]; |
2846 int len=0; | |
2847 | |
2848 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2979 | 2849 /* mpeg4 based DC predictor */ |
2850 len += mpeg4_get_dc_length(intra_dc, n); | |
936 | 2851 if(last_index<1) return len; |
2979 | 2852 i = 1; |
936 | 2853 rl = &rl_intra; |
2854 len_tab = uni_mpeg4_intra_rl_len; | |
2855 } else { | |
2856 if(last_index<0) return 0; | |
2979 | 2857 i = 0; |
936 | 2858 rl = &rl_inter; |
2859 len_tab = uni_mpeg4_inter_rl_len; | |
2860 } | |
2861 | |
2862 /* AC coefs */ | |
2863 last_non_zero = i - 1; | |
2864 for (; i < last_index; i++) { | |
2979 | 2865 int level = block[ scan_table[i] ]; |
2866 if (level) { | |
2867 int run = i - last_non_zero - 1; | |
936 | 2868 level+=64; |
2869 if((level&(~127)) == 0){ | |
2870 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2871 len += len_tab[index]; | |
2872 }else{ //ESC3 | |
2873 len += 7+2+1+6+1+12+1; | |
2874 } | |
2979 | 2875 last_non_zero = i; |
2876 } | |
936 | 2877 } |
2878 /*if(i<=last_index)*/{ | |
2979 | 2879 int level = block[ scan_table[i] ]; |
936 | 2880 int run = i - last_non_zero - 1; |
2881 level+=64; | |
2882 if((level&(~127)) == 0){ | |
2883 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2884 len += len_tab[index]; | |
2885 }else{ //ESC3 | |
2886 len += 7+2+1+6+1+12+1; | |
2887 } | |
2888 } | |
2967 | 2889 |
936 | 2890 return len; |
2891 } | |
2892 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2893 #endif |
0 | 2894 |
2895 | |
2896 /***********************************************/ | |
2897 /* decoding */ | |
2898 | |
2899 static VLC intra_MCBPC_vlc; | |
2900 static VLC inter_MCBPC_vlc; | |
2901 static VLC cbpy_vlc; | |
2902 static VLC mv_vlc; | |
2903 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2904 static VLC sprite_trajectory; |
262 | 2905 static VLC mb_type_b_vlc; |
1655 | 2906 static VLC h263_mbtype_b_vlc; |
2907 static VLC cbpc_b_vlc; | |
0 | 2908 |
2909 /* init vlcs */ | |
2910 | |
2911 /* XXX: find a better solution to handle static init */ | |
2912 void h263_decode_init_vlc(MpegEncContext *s) | |
2913 { | |
2914 static int done = 0; | |
2915 | |
2916 if (!done) { | |
2917 done = 1; | |
2918 | |
2967 | 2919 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
0 | 2920 intra_MCBPC_bits, 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2921 intra_MCBPC_code, 1, 1, 1); |
2967 | 2922 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, |
0 | 2923 inter_MCBPC_bits, 1, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2924 inter_MCBPC_code, 1, 1, 1); |
544 | 2925 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16, |
0 | 2926 &cbpy_tab[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2927 &cbpy_tab[0][0], 2, 1, 1); |
544 | 2928 init_vlc(&mv_vlc, MV_VLC_BITS, 33, |
0 | 2929 &mvtab[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2930 &mvtab[0][0], 2, 1, 1); |
4668 | 2931 init_rl(&rl_inter, static_rl_table_store[0]); |
2932 init_rl(&rl_intra, static_rl_table_store[1]); | |
2933 init_rl(&rvlc_rl_inter, static_rl_table_store[3]); | |
2934 init_rl(&rvlc_rl_intra, static_rl_table_store[4]); | |
2935 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2936 init_vlc_rl(&rl_inter, 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2937 init_vlc_rl(&rl_intra, 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2938 init_vlc_rl(&rvlc_rl_inter, 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2939 init_vlc_rl(&rvlc_rl_intra, 1); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2940 init_vlc_rl(&rl_intra_aic, 1); |
549 | 2941 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2942 &DCtab_lum[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2943 &DCtab_lum[0][0], 2, 1, 1); |
549 | 2944 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, |
0 | 2945 &DCtab_chrom[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2946 &DCtab_chrom[0][0], 2, 1, 1); |
544 | 2947 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15, |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2948 &sprite_trajectory_tab[0][1], 4, 2, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2949 &sprite_trajectory_tab[0][0], 4, 2, 1); |
544 | 2950 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, |
262 | 2951 &mb_type_b_tab[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2952 &mb_type_b_tab[0][0], 2, 1, 1); |
1655 | 2953 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, |
2954 &h263_mbtype_b_tab[0][1], 2, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2955 &h263_mbtype_b_tab[0][0], 2, 1, 1); |
1655 | 2956 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, |
2957 &cbpc_b_tab[0][1], 2, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2271
diff
changeset
|
2958 &cbpc_b_tab[0][0], 2, 1, 1); |
0 | 2959 } |
2960 } | |
2961 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2962 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2963 * Get the GOB height based on picture height. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2964 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2965 int ff_h263_get_gob_height(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2966 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2967 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2968 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2969 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2970 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2971 return 4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2972 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2973 |
1661 | 2974 int ff_h263_decode_mba(MpegEncContext *s) |
2975 { | |
2976 int i, mb_pos; | |
2977 | |
2978 for(i=0; i<6; i++){ | |
1670 | 2979 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2980 } |
2981 mb_pos= get_bits(&s->gb, ff_mba_length[i]); | |
2982 s->mb_x= mb_pos % s->mb_width; | |
2983 s->mb_y= mb_pos / s->mb_width; | |
2984 | |
2985 return mb_pos; | |
2986 } | |
2987 | |
2988 void ff_h263_encode_mba(MpegEncContext *s) | |
2989 { | |
2990 int i, mb_pos; | |
2991 | |
2992 for(i=0; i<6; i++){ | |
1670 | 2993 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2994 } |
2995 mb_pos= s->mb_x + s->mb_width*s->mb_y; | |
2996 put_bits(&s->pb, ff_mba_length[i], mb_pos); | |
2997 } | |
2998 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2999 /** |
1661 | 3000 * decodes the group of blocks header or slice header. |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3001 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3002 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3003 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 3004 { |
1661 | 3005 unsigned int val, gfid, gob_number; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3006 int left; |
2967 | 3007 |
162 | 3008 /* Check for GOB Start Code */ |
3009 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3010 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3011 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3012 |
162 | 3013 /* We have a GBSC probably with GSTUFF */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3014 skip_bits(&s->gb, 16); /* Drop the zeros */ |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
3015 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3016 //MN: we must check the bits left or we might end in a infinite loop (or segfault) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3017 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3018 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3019 } |
2967 | 3020 if(left<=13) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3021 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3022 |
1661 | 3023 if(s->h263_slice_structured){ |
3024 if(get_bits1(&s->gb)==0) | |
3025 return -1; | |
3026 | |
3027 ff_h263_decode_mba(s); | |
3028 | |
3029 if(s->mb_num > 1583) | |
3030 if(get_bits1(&s->gb)==0) | |
3031 return -1; | |
2967 | 3032 |
1661 | 3033 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
3034 if(get_bits1(&s->gb)==0) | |
3035 return -1; | |
3036 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3037 }else{ | |
3038 gob_number = get_bits(&s->gb, 5); /* GN */ | |
3039 s->mb_x= 0; | |
3040 s->mb_y= s->gob_index* gob_number; | |
3041 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3042 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
3043 } | |
2967 | 3044 |
3045 if(s->mb_y >= s->mb_height) | |
1661 | 3046 return -1; |
3047 | |
2967 | 3048 if(s->qscale==0) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3049 return -1; |
1644 | 3050 |
162 | 3051 return 0; |
3052 } | |
3053 | |
290 | 3054 static inline void memsetw(short *tab, int val, int n) |
3055 { | |
3056 int i; | |
3057 for(i=0;i<n;i++) | |
3058 tab[i] = val; | |
3059 } | |
3060 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
3061 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
3062 |
453 | 3063 void ff_mpeg4_init_partitions(MpegEncContext *s) |
3064 { | |
1799 | 3065 uint8_t *start= pbBufPtr(&s->pb); |
3066 uint8_t *end= s->pb.buf_end; | |
3067 int size= end - start; | |
2437
8a30df830ad6
x86_64 pointer typecast fix by (Martin Drab <drab kepler.fjfi.cvut cz>)
michael
parents:
2422
diff
changeset
|
3068 int pb_size = (((long)start + size/3)&(~3)) - (long)start; |
1912 | 3069 int tex_size= (size - 2*pb_size)&(~3); |
2967 | 3070 |
1799 | 3071 set_put_bits_buffer_size(&s->pb, pb_size); |
3072 init_put_bits(&s->tex_pb, start + pb_size , tex_size); | |
1910
5c21b165abf6
ensure that the bitstream buffers for encoding partitioned frames are aligned
michael
parents:
1896
diff
changeset
|
3073 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size); |
453 | 3074 } |
3075 | |
3076 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 3077 { |
1786 | 3078 const int pb2_len = put_bits_count(&s->pb2 ); |
3079 const int tex_pb_len= put_bits_count(&s->tex_pb); | |
3080 const int bits= put_bits_count(&s->pb); | |
453 | 3081 |
3082 if(s->pict_type==I_TYPE){ | |
3083 put_bits(&s->pb, 19, DC_MARKER); | |
3084 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
3085 s->i_tex_bits+= tex_pb_len; | |
3086 }else{ | |
3087 put_bits(&s->pb, 17, MOTION_MARKER); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3088 s->misc_bits+=17 + pb2_len; |
453 | 3089 s->mv_bits+= bits - s->last_bits; |
3090 s->p_tex_bits+= tex_pb_len; | |
3091 } | |
3092 | |
3093 flush_put_bits(&s->pb2); | |
3094 flush_put_bits(&s->tex_pb); | |
3095 | |
1799 | 3096 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf); |
3097 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len); | |
3098 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len); | |
1786 | 3099 s->last_bits= put_bits_count(&s->pb); |
453 | 3100 } |
3101 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
3102 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
3103 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3104 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3105 switch(s->pict_type){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3106 case I_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3107 return 16; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3108 case P_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3109 case S_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3110 return s->f_code+15; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3111 case B_TYPE: |
847 | 3112 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3113 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3114 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3115 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3116 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3117 |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
3118 #ifdef CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
3119 |
453 | 3120 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
3121 { | |
3122 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
3123 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3124 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 3125 put_bits(&s->pb, 1, 1); |
2967 | 3126 |
453 | 3127 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3128 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 3129 put_bits(&s->pb, 1, 0); /* no HEC */ |
3130 } | |
3131 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
3132 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1068
diff
changeset
|
3133 |
453 | 3134 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3135 * check if the next stuff is a resync marker or the end. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3136 * @return 0 if not |
453 | 3137 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3138 static inline int mpeg4_is_resync(MpegEncContext *s){ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3139 int bits_count= get_bits_count(&s->gb); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3140 int v= show_bits(&s->gb, 16); |
2967 | 3141 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3142 if(s->workaround_bugs&FF_BUG_NO_PADDING){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3143 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3144 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3145 |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3146 while(v<=0xFF){ |
4162 | 3147 if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame) |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3148 break; |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3149 skip_bits(&s->gb, 8+s->pict_type); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3150 bits_count+= 8+s->pict_type; |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3151 v= show_bits(&s->gb, 16); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3152 } |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3153 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
3154 if(bits_count + 8 >= s->gb.size_in_bits){ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3155 v>>=8; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3156 v|= 0x7F >> (7-(bits_count&7)); |
2967 | 3157 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3158 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3159 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3160 }else{ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3161 if(v == ff_mpeg4_resync_prefix[bits_count&7]){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3162 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3163 GetBitContext gb= s->gb; |
2967 | 3164 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3165 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3166 align_get_bits(&s->gb); |
2967 | 3167 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3168 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3169 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3170 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3171 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3172 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3173 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3174 if(len>=ff_mpeg4_get_video_packet_prefix_length(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3175 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3176 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3177 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3178 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3179 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3180 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3181 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3182 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3183 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3184 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3185 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 3186 { |
290 | 3187 int mb_num_bits= av_log2(s->mb_num - 1) + 1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3188 int header_extension=0, mb_num, len; |
2967 | 3189 |
453 | 3190 /* is there enough space left for a video packet + header */ |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
3191 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3192 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3193 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3194 if(get_bits1(&s->gb)) break; |
453 | 3195 } |
3196 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3197 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3198 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); |
453 | 3199 return -1; |
3200 } | |
2967 | 3201 |
453 | 3202 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3203 header_extension= get_bits1(&s->gb); |
453 | 3204 //FIXME more stuff here |
3205 } | |
3206 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3207 mb_num= get_bits(&s->gb, mb_num_bits); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3208 if(mb_num>=s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3209 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 3210 return -1; |
3211 } | |
1176 | 3212 if(s->pict_type == B_TYPE){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3213 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3214 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where allready decoded |
1176 | 3215 } |
2967 | 3216 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3217 s->mb_x= mb_num % s->mb_width; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3218 s->mb_y= mb_num / s->mb_width; |
453 | 3219 |
3220 if(s->shape != BIN_ONLY_SHAPE){ | |
2967 | 3221 int qscale= get_bits(&s->gb, s->quant_precision); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3222 if(qscale) |
1644 | 3223 s->chroma_qscale=s->qscale= qscale; |
290 | 3224 } |
3225 | |
3226 if(s->shape == RECT_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3227 header_extension= get_bits1(&s->gb); |
290 | 3228 } |
3229 if(header_extension){ | |
453 | 3230 int time_increment; |
290 | 3231 int time_incr=0; |
453 | 3232 |
2967 | 3233 while (get_bits1(&s->gb) != 0) |
290 | 3234 time_incr++; |
3235 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3236 check_marker(&s->gb, "before time_increment in video packed header"); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3237 time_increment= get_bits(&s->gb, s->time_increment_bits); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3238 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
2967 | 3239 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3240 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 3241 //FIXME not rect stuff here |
3242 | |
3243 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3244 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
3245 //FIXME don't just ignore everything |
821 | 3246 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1914 | 3247 mpeg4_decode_sprite_trajectory(s, &s->gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3248 av_log(s->avctx, AV_LOG_ERROR, "untested\n"); |
290 | 3249 } |
3250 | |
3251 //FIXME reduced res stuff here | |
2967 | 3252 |
290 | 3253 if (s->pict_type != I_TYPE) { |
2979 | 3254 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 3255 if(f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3256 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); |
290 | 3257 } |
3258 } | |
3259 if (s->pict_type == B_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3260 int b_code = get_bits(&s->gb, 3); |
660 | 3261 if(b_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3262 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); |
660 | 3263 } |
2967 | 3264 } |
290 | 3265 } |
3266 } | |
3267 //FIXME new-pred stuff | |
2967 | 3268 |
453 | 3269 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb)); |
3270 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3271 return 0; |
453 | 3272 } |
3273 | |
3274 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
3275 { | |
3276 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 3277 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3278 l_wrap= s->b8_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3279 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3280 c_wrap= s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3281 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1; |
290 | 3282 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3283 #if 0 |
290 | 3284 /* clean DC */ |
453 | 3285 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
3286 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
3287 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3288 #endif |
290 | 3289 |
3290 /* clean AC */ | |
1064 | 3291 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
3292 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
3293 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 3294 |
3295 /* clean MV */ | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
3296 // we can't clear the MVs as they might be needed by a b frame |
1064 | 3297 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
3298 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 3299 s->last_mv[0][0][0]= |
3300 s->last_mv[0][0][1]= | |
3301 s->last_mv[1][0][0]= | |
3302 s->last_mv[1][0][1]= 0; | |
3303 } | |
3304 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3305 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3306 * decodes the group of blocks / video packet header. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3307 * @return <0 if no resync found |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3308 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3309 int ff_h263_resync(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3310 int left, ret; |
2967 | 3311 |
1521 | 3312 if(s->codec_id==CODEC_ID_MPEG4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3313 skip_bits1(&s->gb); |
1521 | 3314 align_get_bits(&s->gb); |
3315 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3316 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3317 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3318 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3319 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3320 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3321 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3322 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3323 return 0; |
453 | 3324 } |
5129 | 3325 //OK, it's not where it is supposed to be ... |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3326 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3327 align_get_bits(&s->gb); |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
3328 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
2967 | 3329 |
3330 for(;left>16+1+5+5; left-=8){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3331 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3332 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3333 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3334 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3335 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3336 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3337 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3338 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3339 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3340 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3341 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3342 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3343 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3344 } |
2967 | 3345 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3346 return -1; |
453 | 3347 } |
3348 | |
3349 /** | |
1034 | 3350 * gets the average motion vector for a GMC MB. |
753 | 3351 * @param n either 0 for the x component or 1 for y |
3352 * @returns the average MV for a GMC MB | |
3353 */ | |
3354 static inline int get_amv(MpegEncContext *s, int n){ | |
3355 int x, y, mb_v, sum, dx, dy, shift; | |
3356 int len = 1 << (s->f_code + 4); | |
3357 const int a= s->sprite_warping_accuracy; | |
2967 | 3358 |
1997 | 3359 if(s->workaround_bugs & FF_BUG_AMV) |
3360 len >>= s->quarter_sample; | |
753 | 3361 |
3362 if(s->real_sprite_warping_points==1){ | |
3363 if(s->divx_version==500 && s->divx_build==413) | |
3364 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
3365 else | |
3366 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
3367 }else{ | |
3368 dx= s->sprite_delta[n][0]; | |
3369 dy= s->sprite_delta[n][1]; | |
3370 shift= s->sprite_shift[0]; | |
3371 if(n) dy -= 1<<(shift + a + 1); | |
3372 else dx -= 1<<(shift + a + 1); | |
3373 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
3374 | |
3375 sum=0; | |
3376 for(y=0; y<16; y++){ | |
3377 int v; | |
2967 | 3378 |
753 | 3379 v= mb_v + dy*y; |
3380 //XXX FIXME optimize | |
3381 for(x=0; x<16; x++){ | |
3382 sum+= v>>shift; | |
3383 v+= dx; | |
3384 } | |
3385 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
3386 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 3387 } |
3388 | |
3389 if (sum < -len) sum= -len; | |
3390 else if (sum >= len) sum= len-1; | |
3391 | |
3392 return sum; | |
3393 } | |
3394 | |
3395 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3396 * decodes first partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3397 * @return number of MBs decoded or <0 if an error occured |
453 | 3398 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3399 static int mpeg4_decode_partition_a(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3400 int mb_num; |
1064 | 3401 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
2967 | 3402 |
453 | 3403 /* decode first partition */ |
3404 mb_num=0; | |
290 | 3405 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3406 for(; s->mb_y<s->mb_height; s->mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3407 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3408 for(; s->mb_x<s->mb_width; s->mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3409 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3410 int cbpc; |
3411 int dir=0; | |
2967 | 3412 |
453 | 3413 mb_num++; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3414 ff_update_block_index(s); |
453 | 3415 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
3416 s->first_slice_line=0; | |
2967 | 3417 |
453 | 3418 if(s->pict_type==I_TYPE){ |
3419 int i; | |
3420 | |
1482 | 3421 do{ |
1873 | 3422 if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
3423 return mb_num-1; | |
3424 } | |
3425 | |
1482 | 3426 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
3427 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3428 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
1482 | 3429 return -1; |
3430 } | |
3431 }while(cbpc == 8); | |
2967 | 3432 |
453 | 3433 s->cbp_table[xy]= cbpc & 3; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3434 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3435 s->mb_intra = 1; |
3436 | |
3437 if(cbpc & 4) { | |
1652 | 3438 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3439 } |
903 | 3440 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3441 |
3442 s->mbintra_table[xy]= 1; | |
3443 for(i=0; i<6; i++){ | |
3444 int dc_pred_dir; | |
2967 | 3445 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3446 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3447 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3448 return -1; |
453 | 3449 } |
3450 dir<<=1; | |
3451 if(dc_pred_dir) dir|=1; | |
3452 } | |
3453 s->pred_dir_table[xy]= dir; | |
3454 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3455 int mx, my, pred_x, pred_y, bits; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3456 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]]; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3457 const int stride= s->b8_stride*2; |
453 | 3458 |
1873 | 3459 try_again: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3460 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3461 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3462 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3463 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3464 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3465 if(bits&0x10000){ |
453 | 3466 /* skip mb */ |
3467 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3468 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 3469 mx= get_amv(s, 0); |
3470 my= get_amv(s, 1); | |
453 | 3471 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3472 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3473 mx=my=0; |
453 | 3474 } |
3475 mot_val[0 ]= mot_val[2 ]= | |
3476 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3477 mot_val[1 ]= mot_val[3 ]= | |
3478 mot_val[1+stride]= mot_val[3+stride]= my; | |
3479 | |
3480 if(s->mbintra_table[xy]) | |
3481 ff_clean_intra_table_entries(s); | |
3482 continue; | |
3483 } | |
1482 | 3484 |
544 | 3485 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 3486 if (cbpc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3487 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3488 return -1; |
453 | 3489 } |
1873 | 3490 if(cbpc == 20) |
3491 goto try_again; | |
1482 | 3492 |
453 | 3493 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
2967 | 3494 |
453 | 3495 s->mb_intra = ((cbpc & 4) != 0); |
2967 | 3496 |
453 | 3497 if(s->mb_intra){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3498 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3499 s->mbintra_table[xy]= 1; |
2967 | 3500 mot_val[0 ]= mot_val[2 ]= |
453 | 3501 mot_val[0+stride]= mot_val[2+stride]= 0; |
3502 mot_val[1 ]= mot_val[3 ]= | |
3503 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3504 }else{ | |
3505 if(s->mbintra_table[xy]) | |
3506 ff_clean_intra_table_entries(s); | |
3507 | |
3508 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | |
3509 s->mcsel= get_bits1(&s->gb); | |
3510 else s->mcsel= 0; | |
2967 | 3511 |
453 | 3512 if ((cbpc & 16) == 0) { |
3513 /* 16x16 motion prediction */ | |
3514 | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3515 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
753 | 3516 if(!s->mcsel){ |
3517 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3518 if (mx >= 0xffff) | |
3519 return -1; | |
3520 | |
3521 my = h263_decode_motion(s, pred_y, s->f_code); | |
3522 if (my >= 0xffff) | |
3523 return -1; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3524 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3525 } else { |
3526 mx = get_amv(s, 0); | |
3527 my = get_amv(s, 1); | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3528 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 3529 } |
753 | 3530 |
453 | 3531 mot_val[0 ]= mot_val[2 ] = |
3532 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3533 mot_val[1 ]= mot_val[3 ]= | |
3534 mot_val[1+stride]= mot_val[3+stride]= my; | |
3535 } else { | |
3536 int i; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3537 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 3538 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3539 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
453 | 3540 mx = h263_decode_motion(s, pred_x, s->f_code); |
3541 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3542 return -1; |
2967 | 3543 |
453 | 3544 my = h263_decode_motion(s, pred_y, s->f_code); |
3545 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3546 return -1; |
453 | 3547 mot_val[0] = mx; |
3548 mot_val[1] = my; | |
3549 } | |
3550 } | |
3551 } | |
3552 } | |
3553 } | |
3554 s->mb_x= 0; | |
3555 } | |
3556 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3557 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3558 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3559 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3560 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3561 * decode second partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3562 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3563 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3564 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3565 int mb_num=0; |
1064 | 3566 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3567 |
453 | 3568 s->mb_x= s->resync_mb_x; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3569 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3570 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3571 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3572 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3573 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3574 |
3575 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3576 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3577 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3578 s->first_slice_line=0; |
2967 | 3579 |
453 | 3580 if(s->pict_type==I_TYPE){ |
3581 int ac_pred= get_bits1(&s->gb); | |
544 | 3582 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3583 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3584 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3585 return -1; |
453 | 3586 } |
2967 | 3587 |
453 | 3588 s->cbp_table[xy]|= cbpy<<2; |
2967 | 3589 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 3590 }else{ /* P || S_TYPE */ |
2967 | 3591 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 3592 int dir=0,i; |
3593 int ac_pred = get_bits1(&s->gb); | |
544 | 3594 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3595 |
3596 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3597 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3598 return -1; |
453 | 3599 } |
2967 | 3600 |
453 | 3601 if(s->cbp_table[xy] & 8) { |
1652 | 3602 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3603 } |
903 | 3604 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3605 |
3606 for(i=0; i<6; i++){ | |
3607 int dc_pred_dir; | |
2967 | 3608 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3609 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3610 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3611 return -1; |
453 | 3612 } |
3613 dir<<=1; | |
3614 if(dc_pred_dir) dir|=1; | |
3615 } | |
3616 s->cbp_table[xy]&= 3; //remove dquant | |
3617 s->cbp_table[xy]|= cbpy<<2; | |
2967 | 3618 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3619 s->pred_dir_table[xy]= dir; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3620 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 3621 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3622 s->cbp_table[xy]= 0; |
3623 }else{ | |
544 | 3624 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3625 |
3626 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3627 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3628 return -1; |
453 | 3629 } |
2967 | 3630 |
453 | 3631 if(s->cbp_table[xy] & 8) { |
1652 | 3632 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3633 } |
903 | 3634 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3635 |
3636 s->cbp_table[xy]&= 3; //remove dquant | |
3637 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3638 } | |
3639 } | |
3640 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3641 if(mb_num >= mb_count) return 0; |
453 | 3642 s->mb_x= 0; |
3643 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3644 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3645 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3646 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3647 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3648 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3649 * @return <0 if error (and sets error type in the error_status_table) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3650 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3651 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3652 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3653 int mb_num; |
1144 | 3654 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
3655 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END; | |
2967 | 3656 |
3657 mb_num= mpeg4_decode_partition_a(s); | |
1144 | 3658 if(mb_num<0){ |
3659 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3660 return -1; |
1144 | 3661 } |
2967 | 3662 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3663 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3664 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); |
1144 | 3665 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3666 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3667 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3668 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3669 s->mb_num_left= mb_num; |
2967 | 3670 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3671 if(s->pict_type==I_TYPE){ |
1873 | 3672 while(show_bits(&s->gb, 9) == 1) |
3673 skip_bits(&s->gb, 9); | |
1257 | 3674 if(get_bits_long(&s->gb, 19)!=DC_MARKER){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3675 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3676 return -1; |
1144 | 3677 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3678 }else{ |
1873 | 3679 while(show_bits(&s->gb, 10) == 1) |
3680 skip_bits(&s->gb, 10); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3681 if(get_bits(&s->gb, 17)!=MOTION_MARKER){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3682 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3683 return -1; |
1144 | 3684 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3685 } |
1144 | 3686 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); |
2967 | 3687 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3688 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
1144 | 3689 if(s->pict_type==P_TYPE) |
3690 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3691 return -1; |
1144 | 3692 }else{ |
3693 if(s->pict_type==P_TYPE) | |
3694 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3695 } |
453 | 3696 |
2967 | 3697 return 0; |
453 | 3698 } |
3699 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3700 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3701 * decode partition C of one MB. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3702 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3703 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3704 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 3705 { |
3706 int cbp, mb_type; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3707 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3708 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3709 mb_type= s->current_picture.mb_type[xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3710 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3711 |
3282 | 3712 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; |
3713 | |
903 | 3714 if(s->current_picture.qscale_table[xy] != s->qscale){ |
1652 | 3715 ff_set_qscale(s, s->current_picture.qscale_table[xy] ); |
453 | 3716 } |
2967 | 3717 |
453 | 3718 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
3719 int i; | |
3720 for(i=0; i<4; i++){ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3721 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3722 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
453 | 3723 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3724 s->mb_intra = IS_INTRA(mb_type); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3725 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3726 if (IS_SKIP(mb_type)) { |
453 | 3727 /* skip mb */ |
3728 for(i=0;i<6;i++) | |
3729 s->block_last_index[i] = -1; | |
3730 s->mv_dir = MV_DIR_FORWARD; | |
3731 s->mv_type = MV_TYPE_16X16; | |
3732 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
3733 s->mcsel=1; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3734 s->mb_skipped = 0; |
453 | 3735 }else{ |
3736 s->mcsel=0; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3737 s->mb_skipped = 1; |
453 | 3738 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3739 }else if(s->mb_intra){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3740 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3741 }else if(!s->mb_intra){ |
3742 // s->mcsel= 0; //FIXME do we need to init that | |
2967 | 3743 |
453 | 3744 s->mv_dir = MV_DIR_FORWARD; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3745 if (IS_8X8(mb_type)) { |
453 | 3746 s->mv_type = MV_TYPE_8X8; |
3747 } else { | |
3748 s->mv_type = MV_TYPE_16X16; | |
3749 } | |
3750 } | |
3751 } else { /* I-Frame */ | |
3752 s->mb_intra = 1; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3753 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3754 } |
3755 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3756 if (!IS_SKIP(mb_type)) { |
1132 | 3757 int i; |
2632 | 3758 s->dsp.clear_blocks(s->block[0]); |
453 | 3759 /* decode each block */ |
3760 for (i = 0; i < 6; i++) { | |
1132 | 3761 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3762 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); |
453 | 3763 return -1; |
3764 } | |
718 | 3765 cbp+=cbp; |
453 | 3766 } |
3767 } | |
290 | 3768 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3769 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3770 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3771 if(--s->mb_num_left <= 0){ |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
3772 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb)); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3773 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3774 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3775 else |
2967 | 3776 return SLICE_NOEND; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3777 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3778 if(mpeg4_is_resync(s)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3779 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3780 if(s->cbp_table[xy+delta]) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3781 return SLICE_END; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3782 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3783 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3784 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3785 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3786 |
1633 | 3787 /** |
3788 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
3789 */ | |
3790 static void preview_obmc(MpegEncContext *s){ | |
3791 GetBitContext gb= s->gb; | |
2967 | 3792 |
1633 | 3793 int cbpc, i, pred_x, pred_y, mx, my; |
3794 int16_t *mot_val; | |
3795 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3796 const int stride= s->b8_stride*2; |
2967 | 3797 |
1633 | 3798 for(i=0; i<4; i++) |
3799 s->block_index[i]+= 2; | |
3800 for(i=4; i<6; i++) | |
3801 s->block_index[i]+= 1; | |
3802 s->mb_x++; | |
2967 | 3803 |
1633 | 3804 assert(s->pict_type == P_TYPE); |
3805 | |
3806 do{ | |
3807 if (get_bits1(&s->gb)) { | |
3808 /* skip mb */ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3809 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; |
2967 | 3810 mot_val[0 ]= mot_val[2 ]= |
1633 | 3811 mot_val[0+stride]= mot_val[2+stride]= 0; |
3812 mot_val[1 ]= mot_val[3 ]= | |
3813 mot_val[1+stride]= mot_val[3+stride]= 0; | |
2967 | 3814 |
1633 | 3815 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
3816 goto end; | |
3817 } | |
3818 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
3819 }while(cbpc == 20); | |
2967 | 3820 |
1633 | 3821 if(cbpc & 4){ |
3822 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
3823 }else{ | |
3824 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3825 if (cbpc & 8) { | |
1656 | 3826 if(s->modified_quant){ |
3827 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
3828 else skip_bits(&s->gb, 5); | |
3829 }else | |
3830 skip_bits(&s->gb, 2); | |
1633 | 3831 } |
2967 | 3832 |
1633 | 3833 if ((cbpc & 16) == 0) { |
2967 | 3834 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
1633 | 3835 /* 16x16 motion prediction */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3836 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1633 | 3837 if (s->umvplus) |
3838 mx = h263p_decode_umotion(s, pred_x); | |
3839 else | |
1655 | 3840 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3841 |
1633 | 3842 if (s->umvplus) |
3843 my = h263p_decode_umotion(s, pred_y); | |
3844 else | |
1655 | 3845 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3846 |
3847 mot_val[0 ]= mot_val[2 ]= | |
1633 | 3848 mot_val[0+stride]= mot_val[2+stride]= mx; |
3849 mot_val[1 ]= mot_val[3 ]= | |
3850 mot_val[1+stride]= mot_val[3+stride]= my; | |
3851 } else { | |
2967 | 3852 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
1633 | 3853 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3854 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 3855 if (s->umvplus) |
3856 mx = h263p_decode_umotion(s, pred_x); | |
3857 else | |
1655 | 3858 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3859 |
1633 | 3860 if (s->umvplus) |
3861 my = h263p_decode_umotion(s, pred_y); | |
2967 | 3862 else |
1655 | 3863 my = h263_decode_motion(s, pred_y, 1); |
1633 | 3864 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
3865 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
3866 mot_val[0] = mx; | |
3867 mot_val[1] = my; | |
3868 } | |
3869 } | |
3870 } | |
3871 end: | |
2967 | 3872 |
1633 | 3873 for(i=0; i<4; i++) |
3874 s->block_index[i]-= 2; | |
3875 for(i=4; i<6; i++) | |
3876 s->block_index[i]-= 1; | |
3877 s->mb_x--; | |
3878 | |
3879 s->gb= gb; | |
3880 } | |
3881 | |
1656 | 3882 static void h263_decode_dquant(MpegEncContext *s){ |
3883 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
3884 | |
3885 if(s->modified_quant){ | |
3886 if(get_bits1(&s->gb)) | |
3887 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; | |
3888 else | |
3889 s->qscale= get_bits(&s->gb, 5); | |
3890 }else | |
3891 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
3892 ff_set_qscale(s, s->qscale); | |
3893 } | |
3894 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3895 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3896 DCTELEM block[6][64]) |
0 | 3897 { |
3898 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3899 int16_t *mot_val; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3900 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
2967 | 3901 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3902 assert(!s->h263_pred); |
2967 | 3903 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3904 if (s->pict_type == P_TYPE) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3905 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3906 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3907 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3908 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3909 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3910 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3911 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3912 s->mv_type = MV_TYPE_16X16; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3913 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3914 s->mv[0][0][0] = 0; |
3915 s->mv[0][0][1] = 0; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3916 s->mb_skipped = !(s->obmc | s->loop_filter); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3917 goto end; |
255 | 3918 } |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3919 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3920 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3921 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3922 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3923 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3924 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3925 }while(cbpc == 20); |
2967 | 3926 |
2632 | 3927 s->dsp.clear_blocks(s->block[0]); |
2967 | 3928 |
0 | 3929 dquant = cbpc & 8; |
3930 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3931 if (s->mb_intra) goto intra; |
2967 | 3932 |
544 | 3933 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2967 | 3934 |
1637 | 3935 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
3936 cbpy ^= 0xF; | |
2967 | 3937 |
1637 | 3938 cbp = (cbpc & 3) | (cbpy << 2); |
0 | 3939 if (dquant) { |
1656 | 3940 h263_decode_dquant(s); |
0 | 3941 } |
2967 | 3942 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3943 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3944 if ((cbpc & 16) == 0) { |
2967 | 3945 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3946 /* 16x16 motion prediction */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3947 s->mv_type = MV_TYPE_16X16; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3948 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3949 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3950 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3951 else |
1655 | 3952 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3953 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3954 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3955 return -1; |
2967 | 3956 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3957 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3958 my = h263p_decode_umotion(s, pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3959 else |
1655 | 3960 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3961 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3962 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3963 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3964 s->mv[0][0][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3965 s->mv[0][0][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3966 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3967 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
2967 | 3968 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3969 } else { |
2967 | 3970 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3971 s->mv_type = MV_TYPE_8X8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3972 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3973 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3974 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3975 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3976 else |
1655 | 3977 mx = h263_decode_motion(s, pred_x, 1); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3978 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3979 return -1; |
2967 | 3980 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3981 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3982 my = h263p_decode_umotion(s, pred_y); |
2967 | 3983 else |
1655 | 3984 my = h263_decode_motion(s, pred_y, 1); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3985 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3986 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3987 s->mv[0][i][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3988 s->mv[0][i][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3989 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3990 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3991 mot_val[0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3992 mot_val[1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3993 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3994 } |
1655 | 3995 |
1796 | 3996 /* decode each block */ |
3997 for (i = 0; i < 6; i++) { | |
3998 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
3999 return -1; | |
4000 cbp+=cbp; | |
4001 } | |
4002 | |
1655 | 4003 if(s->obmc){ |
1796 | 4004 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1) |
1655 | 4005 preview_obmc(s); |
4006 } | |
4007 } else if(s->pict_type==B_TYPE) { | |
4008 int mb_type; | |
4009 const int stride= s->b8_stride; | |
1701 | 4010 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; |
4011 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; | |
1655 | 4012 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; |
4013 | |
2967 | 4014 //FIXME ugly |
4015 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= | |
4016 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= | |
4017 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= | |
1701 | 4018 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; |
1655 | 4019 |
4020 do{ | |
4021 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
4022 if (mb_type < 0){ | |
4023 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
4024 return -1; | |
4025 } | |
4026 | |
4027 mb_type= h263_mb_type_b_map[ mb_type ]; | |
4028 }while(!mb_type); | |
4029 | |
4030 s->mb_intra = IS_INTRA(mb_type); | |
4031 if(HAS_CBP(mb_type)){ | |
2632 | 4032 s->dsp.clear_blocks(s->block[0]); |
1655 | 4033 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); |
4034 if(s->mb_intra){ | |
4035 dquant = IS_QUANT(mb_type); | |
4036 goto intra; | |
4037 } | |
4038 | |
4039 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
4040 | |
4041 if (cbpy < 0){ | |
4042 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
4043 return -1; | |
4044 } | |
2967 | 4045 |
1655 | 4046 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
4047 cbpy ^= 0xF; | |
2967 | 4048 |
1655 | 4049 cbp = (cbpc & 3) | (cbpy << 2); |
4050 }else | |
4051 cbp=0; | |
2967 | 4052 |
1655 | 4053 assert(!s->mb_intra); |
4054 | |
4055 if(IS_QUANT(mb_type)){ | |
1656 | 4056 h263_decode_dquant(s); |
1655 | 4057 } |
4058 | |
4059 if(IS_DIRECT(mb_type)){ | |
4060 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
4061 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); | |
4062 }else{ | |
4063 s->mv_dir = 0; | |
4064 s->mv_type= MV_TYPE_16X16; | |
4065 //FIXME UMV | |
4066 | |
4067 if(USES_LIST(mb_type, 0)){ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4068 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); |
1655 | 4069 s->mv_dir = MV_DIR_FORWARD; |
4070 | |
4071 mx = h263_decode_motion(s, mx, 1); | |
4072 my = h263_decode_motion(s, my, 1); | |
2967 | 4073 |
1655 | 4074 s->mv[0][0][0] = mx; |
4075 s->mv[0][0][1] = my; | |
1701 | 4076 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4077 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4078 } |
2967 | 4079 |
1655 | 4080 if(USES_LIST(mb_type, 1)){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4081 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); |
1655 | 4082 s->mv_dir |= MV_DIR_BACKWARD; |
2967 | 4083 |
1655 | 4084 mx = h263_decode_motion(s, mx, 1); |
4085 my = h263_decode_motion(s, my, 1); | |
1701 | 4086 |
1655 | 4087 s->mv[1][0][0] = mx; |
4088 s->mv[1][0][1] = my; | |
1701 | 4089 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4090 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4091 } |
4092 } | |
2967 | 4093 |
1655 | 4094 s->current_picture.mb_type[xy]= mb_type; |
1796 | 4095 |
4096 /* decode each block */ | |
4097 for (i = 0; i < 6; i++) { | |
4098 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
4099 return -1; | |
4100 cbp+=cbp; | |
4101 } | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4102 } else { /* I-Frame */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4103 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4104 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4105 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4106 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4107 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4108 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4109 }while(cbpc == 8); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4110 |
2632 | 4111 s->dsp.clear_blocks(s->block[0]); |
4112 | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4113 dquant = cbpc & 4; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4114 s->mb_intra = 1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4115 intra: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4116 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4117 if (s->h263_aic) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4118 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4119 if(s->ac_pred){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4120 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
2967 | 4121 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4122 s->h263_aic_dir = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4123 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4124 }else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4125 s->ac_pred = 0; |
2967 | 4126 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4127 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4128 if(cbpy<0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4129 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4130 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4131 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4132 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4133 if (dquant) { |
1656 | 4134 h263_decode_dquant(s); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4135 } |
1796 | 4136 |
4137 /* decode each block */ | |
4138 for (i = 0; i < 6; i++) { | |
4139 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
4140 return -1; | |
4141 cbp+=cbp; | |
4142 } | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4143 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4144 end: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4145 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4146 /* per-MB end of slice check */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4147 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4148 int v= show_bits(&s->gb, 16); |
2967 | 4149 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4150 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4151 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4152 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4153 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4154 if(v==0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4155 return SLICE_END; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4156 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4157 |
2967 | 4158 return SLICE_OK; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4159 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4160 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4161 int ff_mpeg4_decode_mb(MpegEncContext *s, |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4162 DCTELEM block[6][64]) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4163 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4164 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4165 int16_t *mot_val; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4166 static int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4167 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
2967 | 4168 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4169 assert(s->h263_pred); |
2967 | 4170 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4171 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4172 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4173 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4174 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4175 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4176 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4177 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4178 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4179 s->mv_type = MV_TYPE_16X16; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4180 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4181 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4182 s->mcsel=1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4183 s->mv[0][0][0]= get_amv(s, 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4184 s->mv[0][0][1]= get_amv(s, 1); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4185 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4186 s->mb_skipped = 0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4187 }else{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4188 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4189 s->mcsel=0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4190 s->mv[0][0][0] = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4191 s->mv[0][0][1] = 0; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4192 s->mb_skipped = 1; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4193 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4194 goto end; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4195 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4196 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4197 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4198 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4199 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4200 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4201 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4202 }while(cbpc == 20); |
2967 | 4203 |
2632 | 4204 s->dsp.clear_blocks(s->block[0]); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4205 dquant = cbpc & 8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4206 s->mb_intra = ((cbpc & 4) != 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4207 if (s->mb_intra) goto intra; |
2967 | 4208 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4209 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4210 s->mcsel= get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4211 else s->mcsel= 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4212 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; |
2967 | 4213 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4214 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4215 if (dquant) { |
1652 | 4216 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4217 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4218 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE))) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4219 s->interlaced_dct= get_bits1(&s->gb); |
2967 | 4220 |
0 | 4221 s->mv_dir = MV_DIR_FORWARD; |
4222 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4223 if(s->mcsel){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4224 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4225 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4226 s->mv_type = MV_TYPE_16X16; |
753 | 4227 mx= get_amv(s, 0); |
4228 my= get_amv(s, 1); | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4229 s->mv[0][0][0] = mx; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4230 s->mv[0][0][1] = my; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4231 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
2967 | 4232 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4233 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4234 s->mv_type= MV_TYPE_FIELD; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4235 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4236 s->field_select[0][0]= get_bits1(&s->gb); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4237 s->field_select[0][1]= get_bits1(&s->gb); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4238 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4239 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 4240 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4241 for(i=0; i<2; i++){ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4242 mx = h263_decode_motion(s, pred_x, s->f_code); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4243 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4244 return -1; |
2967 | 4245 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4246 my = h263_decode_motion(s, pred_y/2, s->f_code); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4247 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4248 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4249 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4250 s->mv[0][i][0] = mx; |
661 | 4251 s->mv[0][i][1] = my; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4252 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4253 }else{ |
2967 | 4254 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4255 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4256 s->mv_type = MV_TYPE_16X16; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4257 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4258 mx = h263_decode_motion(s, pred_x, s->f_code); |
2967 | 4259 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4260 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4261 return -1; |
2967 | 4262 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4263 my = h263_decode_motion(s, pred_y, s->f_code); |
2967 | 4264 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4265 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4266 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4267 s->mv[0][0][0] = mx; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4268 s->mv[0][0][1] = my; |
255 | 4269 } |
0 | 4270 } else { |
2967 | 4271 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 4272 s->mv_type = MV_TYPE_8X8; |
4273 for(i=0;i<4;i++) { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4274 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4275 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 4276 if (mx >= 0xffff) |
4277 return -1; | |
2967 | 4278 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4279 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 4280 if (my >= 0xffff) |
4281 return -1; | |
4282 s->mv[0][i][0] = mx; | |
4283 s->mv[0][i][1] = my; | |
4284 mot_val[0] = mx; | |
4285 mot_val[1] = my; | |
4286 } | |
4287 } | |
262 | 4288 } else if(s->pict_type==B_TYPE) { |
4289 int modb1; // first bit of modb | |
4290 int modb2; // second bit of modb | |
4291 int mb_type; | |
4292 | |
4293 s->mb_intra = 0; //B-frames never contain intra blocks | |
4294 s->mcsel=0; // ... true gmc blocks | |
4295 | |
4296 if(s->mb_x==0){ | |
674 | 4297 for(i=0; i<2; i++){ |
2967 | 4298 s->last_mv[i][0][0]= |
4299 s->last_mv[i][0][1]= | |
4300 s->last_mv[i][1][0]= | |
674 | 4301 s->last_mv[i][1][1]= 0; |
4302 } | |
262 | 4303 } |
4304 | |
4305 /* if we skipped it in the future P Frame than skip it now too */ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4306 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4307 |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4308 if(s->mb_skipped){ |
262 | 4309 /* skip mb */ |
4310 for(i=0;i<6;i++) | |
4311 s->block_last_index[i] = -1; | |
4312 | |
4313 s->mv_dir = MV_DIR_FORWARD; | |
4314 s->mv_type = MV_TYPE_16X16; | |
4315 s->mv[0][0][0] = 0; | |
4316 s->mv[0][0][1] = 0; | |
4317 s->mv[1][0][0] = 0; | |
4318 s->mv[1][0][1] = 0; | |
2967 | 4319 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4320 goto end; |
262 | 4321 } |
4322 | |
2967 | 4323 modb1= get_bits1(&s->gb); |
666 | 4324 if(modb1){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4325 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 4326 cbp=0; |
4327 }else{ | |
262 | 4328 modb2= get_bits1(&s->gb); |
544 | 4329 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4330 if(mb_type<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4331 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n"); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4332 return -1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4333 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4334 mb_type= mb_type_b_map[ mb_type ]; |
666 | 4335 if(modb2) cbp= 0; |
2632 | 4336 else{ |
4337 s->dsp.clear_blocks(s->block[0]); | |
4338 cbp= get_bits(&s->gb, 6); | |
4339 } | |
666 | 4340 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4341 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 4342 if(get_bits1(&s->gb)){ |
1652 | 4343 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); |
262 | 4344 } |
4345 } | |
664 | 4346 |
4347 if(!s->progressive_sequence){ | |
4348 if(cbp) | |
4349 s->interlaced_dct= get_bits1(&s->gb); | |
4350 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4351 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4352 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4353 mb_type &= ~MB_TYPE_16x16; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4354 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4355 if(USES_LIST(mb_type, 0)){ |
667 | 4356 s->field_select[0][0]= get_bits1(&s->gb); |
4357 s->field_select[0][1]= get_bits1(&s->gb); | |
4358 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4359 if(USES_LIST(mb_type, 1)){ |
667 | 4360 s->field_select[1][0]= get_bits1(&s->gb); |
4361 s->field_select[1][1]= get_bits1(&s->gb); | |
4362 } | |
4363 } | |
666 | 4364 } |
4365 | |
667 | 4366 s->mv_dir = 0; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4367 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 4368 s->mv_type= MV_TYPE_16X16; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4369 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4370 if(USES_LIST(mb_type, 0)){ |
666 | 4371 s->mv_dir = MV_DIR_FORWARD; |
4372 | |
4373 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
4374 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
4375 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
4376 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 4377 } |
2967 | 4378 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4379 if(USES_LIST(mb_type, 1)){ |
666 | 4380 s->mv_dir |= MV_DIR_BACKWARD; |
4381 | |
4382 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
4383 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
4384 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
4385 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
4386 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4387 }else if(!IS_DIRECT(mb_type)){ |
666 | 4388 s->mv_type= MV_TYPE_FIELD; |
667 | 4389 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4390 if(USES_LIST(mb_type, 0)){ |
666 | 4391 s->mv_dir = MV_DIR_FORWARD; |
2967 | 4392 |
666 | 4393 for(i=0; i<2; i++){ |
4394 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
4395 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
4396 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
4397 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
4398 } | |
667 | 4399 } |
2967 | 4400 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4401 if(USES_LIST(mb_type, 1)){ |
666 | 4402 s->mv_dir |= MV_DIR_BACKWARD; |
4403 | |
4404 for(i=0; i<2; i++){ | |
4405 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
4406 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
4407 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
4408 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 4409 } |
4410 } | |
4411 } | |
4412 } | |
2967 | 4413 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4414 if(IS_DIRECT(mb_type)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4415 if(IS_SKIP(mb_type)) |
666 | 4416 mx=my=0; |
4417 else{ | |
4418 mx = h263_decode_motion(s, 0, 1); | |
4419 my = h263_decode_motion(s, 0, 1); | |
4420 } | |
2967 | 4421 |
262 | 4422 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4423 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 4424 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4425 s->current_picture.mb_type[xy]= mb_type; |
262 | 4426 } else { /* I-Frame */ |
1482 | 4427 do{ |
4428 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
4429 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4430 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4431 return -1; |
4432 } | |
4433 }while(cbpc == 8); | |
4434 | |
262 | 4435 dquant = cbpc & 4; |
4436 s->mb_intra = 1; | |
4437 intra: | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4438 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4439 if(s->ac_pred) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4440 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4441 else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4442 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
2967 | 4443 |
544 | 4444 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1482 | 4445 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4446 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4447 return -1; |
4448 } | |
0 | 4449 cbp = (cbpc & 3) | (cbpy << 2); |
3282 | 4450 |
4451 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; | |
4452 | |
0 | 4453 if (dquant) { |
1652 | 4454 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
0 | 4455 } |
2967 | 4456 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4457 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4458 s->interlaced_dct= get_bits1(&s->gb); |
575 | 4459 |
2632 | 4460 s->dsp.clear_blocks(s->block[0]); |
575 | 4461 /* decode each block */ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4462 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4463 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4464 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4465 cbp+=cbp; |
575 | 4466 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4467 goto end; |
0 | 4468 } |
4469 | |
4470 /* decode each block */ | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4471 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4472 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4473 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4474 cbp+=cbp; |
0 | 4475 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4476 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4477 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4478 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4479 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4480 if(mpeg4_is_resync(s)){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4481 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4482 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta]) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4483 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4484 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4485 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4486 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4487 |
2967 | 4488 return SLICE_OK; |
0 | 4489 } |
4490 | |
262 | 4491 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 4492 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
4493 int code, val, sign, shift, l; |
544 | 4494 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 4495 |
4496 if (code == 0) | |
4497 return pred; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4498 if (code < 0) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4499 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4500 |
21 | 4501 sign = get_bits1(&s->gb); |
262 | 4502 shift = f_code - 1; |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4503 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4504 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4505 val = (val - 1) << shift; |
0 | 4506 val |= get_bits(&s->gb, shift); |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4507 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4508 } |
0 | 4509 if (sign) |
4510 val = -val; | |
4511 val += pred; | |
475 | 4512 |
0 | 4513 /* modulo decoding */ |
4514 if (!s->h263_long_vectors) { | |
2093 | 4515 l = INT_BIT - 5 - f_code; |
4516 val = (val<<l)>>l; | |
0 | 4517 } else { |
4518 /* horrible h263 long vector mode */ | |
4519 if (pred < -31 && val < -63) | |
4520 val += 64; | |
4521 if (pred > 32 && val > 63) | |
4522 val -= 64; | |
2967 | 4523 |
0 | 4524 } |
4525 return val; | |
4526 } | |
4527 | |
78 | 4528 /* Decodes RVLC of H.263+ UMV */ |
4529 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
4530 { | |
4531 int code = 0, sign; | |
2967 | 4532 |
78 | 4533 if (get_bits1(&s->gb)) /* Motion difference = 0 */ |
4534 return pred; | |
2967 | 4535 |
78 | 4536 code = 2 + get_bits1(&s->gb); |
2967 | 4537 |
78 | 4538 while (get_bits1(&s->gb)) |
4539 { | |
4540 code <<= 1; | |
4541 code += get_bits1(&s->gb); | |
4542 } | |
4543 sign = code & 1; | |
4544 code >>= 1; | |
2967 | 4545 |
78 | 4546 code = (sign) ? (pred - code) : (pred + code); |
4547 #ifdef DEBUG | |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4548 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code); |
78 | 4549 #endif |
2967 | 4550 return code; |
78 | 4551 |
4552 } | |
4553 | |
0 | 4554 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
4555 int n, int coded) | |
4556 { | |
4557 int code, level, i, j, last, run; | |
4558 RLTable *rl = &rl_inter; | |
1064 | 4559 const uint8_t *scan_table; |
1637 | 4560 GetBitContext gb= s->gb; |
0 | 4561 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4562 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4563 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4564 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4565 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4566 if (s->ac_pred) { |
2967 | 4567 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4568 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4569 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4570 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4571 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4572 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4573 /* DC coef */ |
1641 | 4574 if(s->codec_id == CODEC_ID_RV10){ |
2639 | 4575 #ifdef CONFIG_RV10_DECODER |
1090 | 4576 if (s->rv10_version == 3 && s->pict_type == I_TYPE) { |
0 | 4577 int component, diff; |
4578 component = (n <= 3 ? 0 : n - 4 + 1); | |
4579 level = s->last_dc[component]; | |
4580 if (s->rv10_first_dc_coded[component]) { | |
4581 diff = rv_decode_dc(s, n); | |
4582 if (diff == 0xffff) | |
4583 return -1; | |
4584 level += diff; | |
4585 level = level & 0xff; /* handle wrap round */ | |
4586 s->last_dc[component] = level; | |
4587 } else { | |
4588 s->rv10_first_dc_coded[component] = 1; | |
4589 } | |
1090 | 4590 } else { |
4591 level = get_bits(&s->gb, 8); | |
1975 | 4592 if (level == 255) |
4593 level = 128; | |
1090 | 4594 } |
2639 | 4595 #endif |
1090 | 4596 }else{ |
0 | 4597 level = get_bits(&s->gb, 8); |
1089 | 4598 if((level&0x7F) == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4599 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
1752 | 4600 if(s->error_resilience >= FF_ER_COMPLIANT) |
4601 return -1; | |
1089 | 4602 } |
0 | 4603 if (level == 255) |
4604 level = 128; | |
4605 } | |
4606 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4607 i = 1; |
0 | 4608 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4609 i = 0; |
0 | 4610 } |
4611 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4612 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4613 goto not_coded; |
0 | 4614 s->block_last_index[n] = i - 1; |
4615 return 0; | |
4616 } | |
1637 | 4617 retry: |
0 | 4618 for(;;) { |
544 | 4619 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4620 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4621 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 4622 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4623 } |
0 | 4624 if (code == rl->n) { |
4625 /* escape */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4626 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4627 int is11 = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4628 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4629 run = get_bits(&s->gb, 6); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4630 if(is11){ |
1356 | 4631 level = get_sbits(&s->gb, 11); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4632 } else { |
1356 | 4633 level = get_sbits(&s->gb, 7); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4634 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4635 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4636 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4637 run = get_bits(&s->gb, 6); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4638 level = (int8_t)get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4639 if(level == -128){ |
1641 | 4640 if (s->codec_id == CODEC_ID_RV10) { |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4641 /* XXX: should patch encoder too */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4642 level = get_sbits(&s->gb, 12); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4643 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4644 level = get_bits(&s->gb, 5); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4645 level |= get_sbits(&s->gb, 6)<<5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4646 } |
1089 | 4647 } |
0 | 4648 } |
4649 } else { | |
4650 run = rl->table_run[code]; | |
4651 level = rl->table_level[code]; | |
4652 last = code >= rl->last; | |
21 | 4653 if (get_bits1(&s->gb)) |
0 | 4654 level = -level; |
4655 } | |
4656 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4657 if (i >= 64){ |
1637 | 4658 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ |
5129 | 4659 //Looks like a hack but no, it's the way it is supposed to work ... |
1637 | 4660 rl = &rl_intra_aic; |
4661 i = 0; | |
4662 s->gb= gb; | |
4663 memset(block, 0, sizeof(DCTELEM)*64); | |
4664 goto retry; | |
4665 } | |
2406 | 4666 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); |
0 | 4667 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4668 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4669 j = scan_table[i]; |
0 | 4670 block[j] = level; |
4671 if (last) | |
4672 break; | |
4673 i++; | |
4674 } | |
2967 | 4675 not_coded: |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4676 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4677 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
4678 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4679 } |
0 | 4680 s->block_last_index[n] = i; |
4681 return 0; | |
4682 } | |
4683 | |
1034 | 4684 /** |
4685 * decodes the dc value. | |
4686 * @param n block index (0-3 are luma, 4-5 are chroma) | |
4687 * @param dir_ptr the prediction direction will be stored here | |
4688 * @return the quantized dc | |
4689 */ | |
453 | 4690 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 4691 { |
2003 | 4692 int level, code; |
0 | 4693 |
2967 | 4694 if (n < 4) |
544 | 4695 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
2967 | 4696 else |
544 | 4697 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 4698 if (code < 0 || code > 9 /* && s->nbit<9 */){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4699 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
0 | 4700 return -1; |
453 | 4701 } |
0 | 4702 if (code == 0) { |
4703 level = 0; | |
4704 } else { | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4705 if(IS_3IV1){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4706 if(code==1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4707 level= 2*get_bits1(&s->gb)-1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4708 else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4709 if(get_bits1(&s->gb)) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4710 level = get_bits(&s->gb, code-1) + (1<<(code-1)); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4711 else |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4712 level = -get_bits(&s->gb, code-1) - (1<<(code-1)); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4713 } |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4714 }else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4715 level = get_xbits(&s->gb, code); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4716 } |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4717 |
453 | 4718 if (code > 8){ |
4719 if(get_bits1(&s->gb)==0){ /* marker */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4720 if(s->error_resilience>=2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4721 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n"); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4722 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4723 } |
453 | 4724 } |
4725 } | |
0 | 4726 } |
2003 | 4727 |
4728 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); | |
0 | 4729 } |
4730 | |
453 | 4731 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4732 * decodes a block. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4733 * @return <0 if an error occured |
453 | 4734 */ |
4735 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 4736 int n, int coded, int intra, int rvlc) |
0 | 4737 { |
549 | 4738 int level, i, last, run; |
0 | 4739 int dc_pred_dir; |
575 | 4740 RLTable * rl; |
4741 RL_VLC_ELEM * rl_vlc; | |
1064 | 4742 const uint8_t * scan_table; |
549 | 4743 int qmul, qadd; |
0 | 4744 |
1132 | 4745 //Note intra & rvlc should be optimized away if this is inlined |
2967 | 4746 |
575 | 4747 if(intra) { |
3282 | 4748 if(s->use_intra_dc_vlc){ |
2979 | 4749 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4750 if(s->partitioned_frame){ |
453 | 4751 level = s->dc_val[0][ s->block_index[n] ]; |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
4752 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
4753 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4754 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 4755 }else{ |
4756 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
4757 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4758 return -1; |
453 | 4759 } |
0 | 4760 block[0] = level; |
549 | 4761 i = 0; |
1520 | 4762 }else{ |
4763 i = -1; | |
3182 | 4764 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0); |
2967 | 4765 } |
4766 if (!coded) | |
0 | 4767 goto not_coded; |
2967 | 4768 |
4769 if(rvlc){ | |
1132 | 4770 rl = &rvlc_rl_intra; |
4771 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
4772 }else{ | |
4773 rl = &rl_intra; | |
4774 rl_vlc = rl_intra.rl_vlc[0]; | |
4775 } | |
718 | 4776 if (s->ac_pred) { |
2967 | 4777 if (dc_pred_dir == 0) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4778 scan_table = s->intra_v_scantable.permutated; /* left */ |
0 | 4779 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4780 scan_table = s->intra_h_scantable.permutated; /* top */ |
0 | 4781 } else { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4782 scan_table = s->intra_scantable.permutated; |
0 | 4783 } |
549 | 4784 qmul=1; |
4785 qadd=0; | |
0 | 4786 } else { |
549 | 4787 i = -1; |
0 | 4788 if (!coded) { |
549 | 4789 s->block_last_index[n] = i; |
0 | 4790 return 0; |
4791 } | |
1132 | 4792 if(rvlc) rl = &rvlc_rl_inter; |
4793 else rl = &rl_inter; | |
2967 | 4794 |
718 | 4795 scan_table = s->intra_scantable.permutated; |
661 | 4796 |
591 | 4797 if(s->mpeg_quant){ |
4798 qmul=1; | |
4799 qadd=0; | |
2967 | 4800 if(rvlc){ |
4801 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
1132 | 4802 }else{ |
2967 | 4803 rl_vlc = rl_inter.rl_vlc[0]; |
1132 | 4804 } |
591 | 4805 }else{ |
4806 qmul = s->qscale << 1; | |
4807 qadd = (s->qscale - 1) | 1; | |
2967 | 4808 if(rvlc){ |
4809 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
1132 | 4810 }else{ |
2967 | 4811 rl_vlc = rl_inter.rl_vlc[s->qscale]; |
1132 | 4812 } |
591 | 4813 } |
0 | 4814 } |
549 | 4815 { |
4816 OPEN_READER(re, &s->gb); | |
0 | 4817 for(;;) { |
549 | 4818 UPDATE_CACHE(re, &s->gb); |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4819 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
549 | 4820 if (level==0) { |
2967 | 4821 /* escape */ |
1132 | 4822 if(rvlc){ |
4823 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4824 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); |
1132 | 4825 return -1; |
4826 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4827 |
1132 | 4828 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
4829 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4830 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
4831 UPDATE_CACHE(re, &s->gb); | |
2967 | 4832 |
1132 | 4833 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4834 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); |
1132 | 4835 return -1; |
4836 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4837 |
1132 | 4838 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); |
2967 | 4839 |
1132 | 4840 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4841 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); |
1132 | 4842 return -1; |
4843 }; SKIP_CACHE(re, &s->gb, 5); | |
4844 | |
4845 level= level * qmul + qadd; | |
4846 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
4847 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
4848 | |
4849 i+= run + 1; | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4850 if(last) i+=192; |
1132 | 4851 }else{ |
549 | 4852 int cache; |
4853 cache= GET_CACHE(re, &s->gb); | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4854 |
2967 | 4855 if(IS_3IV1) |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4856 cache ^= 0xC0000000; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4857 |
549 | 4858 if (cache&0x80000000) { |
4859 if (cache&0x40000000) { | |
0 | 4860 /* third escape */ |
549 | 4861 SKIP_CACHE(re, &s->gb, 2); |
4862 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4863 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4864 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
4865 UPDATE_CACHE(re, &s->gb); | |
4866 | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4867 if(IS_3IV1){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4868 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4869 }else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4870 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4871 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n"); |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4872 return -1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4873 }; SKIP_CACHE(re, &s->gb, 1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4874 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4875 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4876 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4877 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4878 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n"); |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4879 return -1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4880 }; LAST_SKIP_CACHE(re, &s->gb, 1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4881 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4882 SKIP_COUNTER(re, &s->gb, 1+12+1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4883 } |
2967 | 4884 |
1525
39efe24058ad
dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents:
1522
diff
changeset
|
4885 #if 0 |
39efe24058ad
dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents:
1522
diff
changeset
|
4886 if(s->error_resilience >= FF_ER_COMPLIANT){ |
4001 | 4887 const int abs_level= FFABS(level); |
1525
39efe24058ad
dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents:
1522
diff
changeset
|
4888 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
498 | 4889 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 4890 if(abs_level <= rl->max_level[last][run]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4891 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4892 return -1; |
453 | 4893 } |
905
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4894 if(s->error_resilience > FF_ER_COMPLIANT){ |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4895 if(abs_level <= rl->max_level[last][run]*2){ |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4896 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); |
905
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4897 return -1; |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4898 } |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4899 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4900 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); |
905
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4901 return -1; |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4902 } |
453 | 4903 } |
4904 } | |
4905 } | |
4906 #endif | |
2979 | 4907 if (level>0) level= level * qmul + qadd; |
549 | 4908 else level= level * qmul - qadd; |
4909 | |
2080 | 4910 if((unsigned)(level + 2048) > 4095){ |
4911 if(s->error_resilience > FF_ER_COMPLIANT){ | |
4912 if(level > 2560 || level<-2560){ | |
4913 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | |
4914 return -1; | |
4915 } | |
4916 } | |
4917 level= level<0 ? -2048 : 2047; | |
4918 } | |
4919 | |
549 | 4920 i+= run + 1; |
4921 if(last) i+=192; | |
0 | 4922 } else { |
4923 /* second escape */ | |
549 | 4924 #if MIN_CACHE_BITS < 20 |
4925 LAST_SKIP_BITS(re, &s->gb, 2); | |
4926 UPDATE_CACHE(re, &s->gb); | |
4927 #else | |
4928 SKIP_BITS(re, &s->gb, 2); | |
4929 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4930 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4931 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing |
4932 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4933 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4934 } |
4935 } else { | |
4936 /* first escape */ | |
549 | 4937 #if MIN_CACHE_BITS < 19 |
4938 LAST_SKIP_BITS(re, &s->gb, 1); | |
4939 UPDATE_CACHE(re, &s->gb); | |
4940 #else | |
4941 SKIP_BITS(re, &s->gb, 1); | |
4942 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4943 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4944 i+= run; |
4945 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4946 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4947 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4948 } |
1132 | 4949 } |
0 | 4950 } else { |
549 | 4951 i+= run; |
4952 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4953 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4954 } |
549 | 4955 if (i > 62){ |
4956 i-= 192; | |
4957 if(i&(~63)){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4958 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4959 return -1; |
549 | 4960 } |
4961 | |
4962 block[scan_table[i]] = level; | |
0 | 4963 break; |
549 | 4964 } |
4965 | |
4966 block[scan_table[i]] = level; | |
0 | 4967 } |
549 | 4968 CLOSE_READER(re, &s->gb); |
4969 } | |
0 | 4970 not_coded: |
1520 | 4971 if (intra) { |
3282 | 4972 if(!s->use_intra_dc_vlc){ |
2003 | 4973 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); |
2967 | 4974 |
3181 | 4975 i -= i>>31; //if(i == -1) i=0; |
1520 | 4976 } |
4977 | |
0 | 4978 mpeg4_pred_ac(s, block, n, dc_pred_dir); |
4979 if (s->ac_pred) { | |
549 | 4980 i = 63; /* XXX: not optimal */ |
0 | 4981 } |
4982 } | |
549 | 4983 s->block_last_index[n] = i; |
0 | 4984 return 0; |
4985 } | |
4986 | |
4987 /* most is hardcoded. should extend to handle all h263 streams */ | |
4988 int h263_decode_picture_header(MpegEncContext *s) | |
4989 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4990 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4991 uint32_t startcode; |
2967 | 4992 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4993 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4994 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4995 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4996 |
1393 | 4997 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) { |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4998 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
2967 | 4999 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5000 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5001 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5002 } |
2967 | 5003 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5004 if (startcode != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5005 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 5006 return -1; |
355 | 5007 } |
5008 /* temporal reference */ | |
1865 | 5009 i = get_bits(&s->gb, 8); /* picture timestamp */ |
5010 if( (s->picture_number&~0xFF)+i < s->picture_number) | |
5011 i+= 256; | |
2886 | 5012 s->current_picture_ptr->pts= |
1865 | 5013 s->picture_number= (s->picture_number&~0xFF) + i; |
355 | 5014 |
2967 | 5015 /* PTYPE starts here */ |
355 | 5016 if (get_bits1(&s->gb) != 1) { |
5017 /* marker */ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5018 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
355 | 5019 return -1; |
5020 } | |
5021 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5022 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 5023 return -1; /* h263 id */ |
5024 } | |
5025 skip_bits1(&s->gb); /* split screen off */ | |
5026 skip_bits1(&s->gb); /* camera off */ | |
5027 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 5028 |
5029 format = get_bits(&s->gb, 3); | |
355 | 5030 /* |
5031 0 forbidden | |
5032 1 sub-QCIF | |
5033 10 QCIF | |
2979 | 5034 7 extended PTYPE (PLUSPTYPE) |
355 | 5035 */ |
0 | 5036 |
161 | 5037 if (format != 7 && format != 6) { |
0 | 5038 s->h263_plus = 0; |
5039 /* H.263v1 */ | |
5040 width = h263_format[format][0]; | |
5041 height = h263_format[format][1]; | |
5042 if (!width) | |
5043 return -1; | |
2967 | 5044 |
21 | 5045 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 5046 |
2967 | 5047 s->h263_long_vectors = get_bits1(&s->gb); |
0 | 5048 |
355 | 5049 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5050 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); |
2979 | 5051 return -1; /* SAC: off */ |
355 | 5052 } |
1633 | 5053 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5054 s->unrestricted_mv = s->h263_long_vectors || s->obmc; | |
2967 | 5055 |
355 | 5056 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5057 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n"); |
2979 | 5058 return -1; /* not PB frame */ |
355 | 5059 } |
1644 | 5060 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 5061 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
1393 | 5062 |
5063 s->width = width; | |
5064 s->height = height; | |
1865 | 5065 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
2637 | 5066 s->avctx->time_base= (AVRational){1001, 30000}; |
0 | 5067 } else { |
161 | 5068 int ufep; |
2967 | 5069 |
0 | 5070 /* H.263v2 */ |
161 | 5071 s->h263_plus = 1; |
5072 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 5073 |
2967 | 5074 /* ufep other than 0 and 1 are reserved */ |
161 | 5075 if (ufep == 1) { |
2967 | 5076 /* OPPTYPE */ |
161 | 5077 format = get_bits(&s->gb, 3); |
4652 | 5078 dprintf(s->avctx, "ufep=1, format: %d\n", format); |
1872 | 5079 s->custom_pcf= get_bits1(&s->gb); |
5513 | 5080 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ |
1644 | 5081 if (get_bits1(&s->gb) != 0) { |
5082 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); | |
5083 } | |
1633 | 5084 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5085 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ | |
1644 | 5086 s->loop_filter= get_bits1(&s->gb); |
5087 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; | |
2967 | 5088 |
1661 | 5089 s->h263_slice_structured= get_bits1(&s->gb); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5090 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5091 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5092 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5093 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5094 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5095 } |
1637 | 5096 s->alt_inter_vlc= get_bits1(&s->gb); |
1639 | 5097 s->modified_quant= get_bits1(&s->gb); |
1644 | 5098 if(s->modified_quant) |
5099 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 5100 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5101 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 5102 |
161 | 5103 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 5104 } else if (ufep != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5105 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); |
0 | 5106 return -1; |
355 | 5107 } |
2967 | 5108 |
78 | 5109 /* MPPTYPE */ |
1655 | 5110 s->pict_type = get_bits(&s->gb, 3); |
5111 switch(s->pict_type){ | |
5112 case 0: s->pict_type= I_TYPE;break; | |
5113 case 1: s->pict_type= P_TYPE;break; | |
5114 case 3: s->pict_type= B_TYPE;break; | |
5115 case 7: s->pict_type= I_TYPE;break; //ZYGO | |
5116 default: | |
0 | 5117 return -1; |
1655 | 5118 } |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5119 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5120 s->no_rounding = get_bits1(&s->gb); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5121 skip_bits(&s->gb, 4); |
2967 | 5122 |
78 | 5123 /* Get the picture dimensions */ |
161 | 5124 if (ufep) { |
5125 if (format == 6) { | |
5126 /* Custom Picture Format (CPFMT) */ | |
355 | 5127 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4652 | 5128 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info); |
355 | 5129 /* aspect ratios: |
5130 0 - forbidden | |
5131 1 - 1:1 | |
5132 2 - 12:11 (CIF 4:3) | |
5133 3 - 10:11 (525-type 4:3) | |
5134 4 - 16:11 (CIF 16:9) | |
5135 5 - 40:33 (525-type 16:9) | |
5136 6-14 - reserved | |
5137 */ | |
161 | 5138 width = (get_bits(&s->gb, 9) + 1) * 4; |
5139 skip_bits1(&s->gb); | |
5140 height = get_bits(&s->gb, 9) * 4; | |
4652 | 5141 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
5142 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 5143 /* aspected dimensions */ |
1548 | 5144 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); |
5145 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); | |
887 | 5146 }else{ |
1548 | 5147 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
355 | 5148 } |
5149 } else { | |
161 | 5150 width = h263_format[format][0]; |
5151 height = h263_format[format][1]; | |
1865 | 5152 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
161 | 5153 } |
5154 if ((width == 0) || (height == 0)) | |
5155 return -1; | |
5156 s->width = width; | |
5157 s->height = height; | |
1872 | 5158 |
5159 if(s->custom_pcf){ | |
5160 int gcd; | |
2637 | 5161 s->avctx->time_base.den= 1800000; |
5162 s->avctx->time_base.num= 1000 + get_bits1(&s->gb); | |
5163 s->avctx->time_base.num*= get_bits(&s->gb, 7); | |
5164 if(s->avctx->time_base.num == 0){ | |
1872 | 5165 av_log(s, AV_LOG_ERROR, "zero framerate\n"); |
5166 return -1; | |
5167 } | |
2637 | 5168 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num); |
5169 s->avctx->time_base.den /= gcd; | |
5170 s->avctx->time_base.num /= gcd; | |
5171 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num); | |
1872 | 5172 }else{ |
2637 | 5173 s->avctx->time_base= (AVRational){1001, 30000}; |
1872 | 5174 } |
5175 } | |
2967 | 5176 |
1872 | 5177 if(s->custom_pcf){ |
5178 skip_bits(&s->gb, 2); //extended Temporal reference | |
5179 } | |
5180 | |
5181 if (ufep) { | |
1089 | 5182 if (s->umvplus) { |
5183 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
2967 | 5184 skip_bits1(&s->gb); |
161 | 5185 } |
1661 | 5186 if(s->h263_slice_structured){ |
5187 if (get_bits1(&s->gb) != 0) { | |
5188 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); | |
5189 } | |
5190 if (get_bits1(&s->gb) != 0) { | |
5191 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); | |
5192 } | |
5193 } | |
78 | 5194 } |
2967 | 5195 |
0 | 5196 s->qscale = get_bits(&s->gb, 5); |
5197 } | |
1670 | 5198 |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5199 s->mb_width = (s->width + 15) / 16; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5200 s->mb_height = (s->height + 15) / 16; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5201 s->mb_num = s->mb_width * s->mb_height; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5202 |
0 | 5203 /* PEI */ |
21 | 5204 while (get_bits1(&s->gb) != 0) { |
5205 skip_bits(&s->gb, 8); | |
0 | 5206 } |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5207 |
1670 | 5208 if(s->h263_slice_structured){ |
5209 if (get_bits1(&s->gb) != 1) { | |
5210 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); | |
5211 return -1; | |
5212 } | |
5213 | |
5214 ff_h263_decode_mba(s); | |
5215 | |
5216 if (get_bits1(&s->gb) != 1) { | |
5217 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
5218 return -1; | |
5219 } | |
5220 } | |
0 | 5221 s->f_code = 1; |
2967 | 5222 |
498 | 5223 if(s->h263_aic){ |
2967 | 5224 s->y_dc_scale_table= |
1639 | 5225 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 5226 }else{ |
5227 s->y_dc_scale_table= | |
5228 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
5229 } | |
5230 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5231 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
5403 | 5232 show_pict_info(s); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5233 } |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5234 #if 1 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
5235 if (s->pict_type == I_TYPE && s->codec_tag == ff_get_fourcc("ZYGO")){ |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5236 int i,j; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5237 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5238 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5239 for(i=0; i<13; i++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5240 for(j=0; j<3; j++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5241 int v= get_bits(&s->gb, 8); |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5242 v |= get_sbits(&s->gb, 8)<<8; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5243 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5244 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5245 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5246 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5247 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5248 } |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5249 #endif |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5250 |
0 | 5251 return 0; |
5252 } | |
5253 | |
1914 | 5254 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb) |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5255 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5256 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5257 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5258 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5259 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5260 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5261 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}}; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5262 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5263 int virtual_ref[2][2]; |
753 | 5264 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5265 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5266 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5267 int h= s->height; |
753 | 5268 int min_ab; |
5269 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5270 for(i=0; i<s->num_sprite_warping_points; i++){ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5271 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5272 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5273 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5274 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5275 if(length){ |
1914 | 5276 x= get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5277 } |
1914 | 5278 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */ |
2967 | 5279 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5280 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5281 if(length){ |
1914 | 5282 y=get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5283 } |
1914 | 5284 skip_bits1(gb); /* marker bit */ |
255 | 5285 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5286 d[i][0]= x; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5287 d[i][1]= y; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5288 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5289 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5290 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5291 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h' |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5292 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5293 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5294 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5295 // Note, the 4th point isn't used for GMC |
262 | 5296 if(s->divx_version==500 && s->divx_build==413){ |
5297 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
5298 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
5299 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
5300 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
5301 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
5302 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
5303 } else { | |
5304 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
5305 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
5306 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
5307 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
5308 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
5309 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
5310 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5311 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5312 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ |
2967 | 5313 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5314 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5315 // perhaps it should be reordered to be more readable ... |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5316 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5317 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form |
2967 | 5318 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 5319 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w); |
2967 | 5320 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 5321 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w); |
2967 | 5322 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 5323 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h); |
2967 | 5324 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 5325 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h); |
2967 | 5326 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5327 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5328 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5329 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5330 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5331 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5332 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5333 s->sprite_offset[1][1]= 0; |
753 | 5334 s->sprite_delta[0][0]= a; |
5335 s->sprite_delta[0][1]= 0; | |
5336 s->sprite_delta[1][0]= 0; | |
5337 s->sprite_delta[1][1]= a; | |
5338 s->sprite_shift[0]= 0; | |
5339 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5340 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5341 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5342 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5343 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5344 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5345 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 5346 s->sprite_delta[0][0]= a; |
5347 s->sprite_delta[0][1]= 0; | |
5348 s->sprite_delta[1][0]= 0; | |
5349 s->sprite_delta[1][1]= a; | |
5350 s->sprite_shift[0]= 0; | |
5351 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5352 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5353 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5354 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 5355 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
5356 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
5357 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5358 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 5359 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
5360 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
5361 + (1<<(alpha+rho-1)); | |
5362 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
5363 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
2967 | 5364 +2*w2*r*sprite_ref[0][0] |
5365 - 16*w2 | |
753 | 5366 + (1<<(alpha+rho+1))); |
2967 | 5367 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) |
753 | 5368 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) |
2967 | 5369 +2*w2*r*sprite_ref[0][1] |
753 | 5370 - 16*w2 |
5371 + (1<<(alpha+rho+1))); | |
5372 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
5373 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
5374 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
5375 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
2967 | 5376 |
753 | 5377 s->sprite_shift[0]= alpha+rho; |
5378 s->sprite_shift[1]= alpha+rho+2; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5379 break; |
753 | 5380 case 3: |
847 | 5381 min_ab= FFMIN(alpha, beta); |
753 | 5382 w3= w2>>min_ab; |
5383 h3= h2>>min_ab; | |
5384 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
5385 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
5386 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
5387 + (1<<(alpha+beta+rho-min_ab-1)); | |
5388 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
5389 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
5390 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
5391 + (1<<(alpha+beta+rho-min_ab-1)); | |
5392 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
5393 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
5394 + 2*w2*h3*r*sprite_ref[0][0] | |
5395 - 16*w2*h3 | |
5396 + (1<<(alpha+beta+rho-min_ab+1)); | |
5397 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
5398 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
5399 + 2*w2*h3*r*sprite_ref[0][1] | |
5400 - 16*w2*h3 | |
5401 + (1<<(alpha+beta+rho-min_ab+1)); | |
5402 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
5403 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
5404 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
5405 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
2967 | 5406 |
753 | 5407 s->sprite_shift[0]= alpha + beta + rho - min_ab; |
5408 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5409 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5410 } |
2967 | 5411 /* try to simplify the situation */ |
753 | 5412 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
5413 && s->sprite_delta[0][1] == 0 | |
5414 && s->sprite_delta[1][0] == 0 | |
5415 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 5416 { |
753 | 5417 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
5418 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
5419 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
5420 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
5421 s->sprite_delta[0][0]= a; | |
5422 s->sprite_delta[0][1]= 0; | |
5423 s->sprite_delta[1][0]= 0; | |
5424 s->sprite_delta[1][1]= a; | |
5425 s->sprite_shift[0]= 0; | |
5426 s->sprite_shift[1]= 0; | |
255 | 5427 s->real_sprite_warping_points=1; |
5428 } | |
753 | 5429 else{ |
5430 int shift_y= 16 - s->sprite_shift[0]; | |
5431 int shift_c= 16 - s->sprite_shift[1]; | |
5432 //printf("shifts %d %d\n", shift_y, shift_c); | |
5433 for(i=0; i<2; i++){ | |
5434 s->sprite_offset[0][i]<<= shift_y; | |
5435 s->sprite_offset[1][i]<<= shift_c; | |
5436 s->sprite_delta[0][i]<<= shift_y; | |
5437 s->sprite_delta[1][i]<<= shift_y; | |
5438 s->sprite_shift[i]= 16; | |
5439 } | |
255 | 5440 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 5441 } |
5442 #if 0 | |
5443 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", | |
5444 vop_ref[0][0], vop_ref[0][1], | |
5445 vop_ref[1][0], vop_ref[1][1], | |
5446 vop_ref[2][0], vop_ref[2][1], | |
2967 | 5447 sprite_ref[0][0], sprite_ref[0][1], |
5448 sprite_ref[1][0], sprite_ref[1][1], | |
5449 sprite_ref[2][0], sprite_ref[2][1], | |
5450 virtual_ref[0][0], virtual_ref[0][1], | |
753 | 5451 virtual_ref[1][0], virtual_ref[1][1] |
5452 ); | |
2967 | 5453 |
753 | 5454 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", |
5455 s->sprite_offset[0][0], s->sprite_offset[0][1], | |
5456 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
5457 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
5458 s->sprite_shift[0] | |
5459 ); | |
5460 #endif | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5461 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5462 |
942 | 5463 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
5464 int hours, minutes, seconds; | |
5465 | |
5466 hours= get_bits(gb, 5); | |
5467 minutes= get_bits(gb, 6); | |
5468 skip_bits1(gb); | |
5469 seconds= get_bits(gb, 6); | |
5470 | |
5471 s->time_base= seconds + 60*(minutes + 60*hours); | |
5472 | |
5473 skip_bits1(gb); | |
5474 skip_bits1(gb); | |
2967 | 5475 |
942 | 5476 return 0; |
5477 } | |
5478 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5479 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5480 int width, height, vo_ver_id; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5481 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5482 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5483 skip_bits(gb, 1); /* random access */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5484 s->vo_type= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5485 if (get_bits1(gb) != 0) { /* is_ol_id */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5486 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5487 skip_bits(gb, 3); /* vo_priority */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5488 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5489 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5490 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5491 //printf("vo type:%d\n",s->vo_type); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5492 s->aspect_ratio_info= get_bits(gb, 4); |
2967 | 5493 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
1548 | 5494 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width |
5495 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height | |
887 | 5496 }else{ |
1548 | 5497 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5498 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5499 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5500 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5501 int chroma_format= get_bits(gb, 2); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5502 if(chroma_format!=1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5503 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5504 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5505 s->low_delay= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5506 if(get_bits1(gb)){ /* vbv parameters */ |
2979 | 5507 get_bits(gb, 15); /* first_half_bitrate */ |
5508 skip_bits1(gb); /* marker */ | |
5509 get_bits(gb, 15); /* latter_half_bitrate */ | |
5510 skip_bits1(gb); /* marker */ | |
5511 get_bits(gb, 15); /* first_half_vbv_buffer_size */ | |
5512 skip_bits1(gb); /* marker */ | |
5513 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ | |
5514 get_bits(gb, 11); /* first_half_vbv_occupancy */ | |
5515 skip_bits1(gb); /* marker */ | |
5516 get_bits(gb, 15); /* latter_half_vbv_occupancy */ | |
5517 skip_bits1(gb); /* marker */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5518 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5519 }else{ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5520 // set low delay flag only once the smartest? low delay detection won't be overriden |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5521 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5522 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5523 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5524 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5525 s->shape = get_bits(gb, 2); /* vol shape */ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5526 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5527 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5528 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5529 skip_bits(gb, 4); //video_object_layer_shape_extension |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5530 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5531 |
1411 | 5532 check_marker(gb, "before time_increment_resolution"); |
2967 | 5533 |
2637 | 5534 s->avctx->time_base.den = get_bits(gb, 16); |
2812 | 5535 if(!s->avctx->time_base.den){ |
5536 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n"); | |
5537 return -1; | |
5538 } | |
2967 | 5539 |
2637 | 5540 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5541 if (s->time_increment_bits < 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5542 s->time_increment_bits = 1; |
2967 | 5543 |
1411 | 5544 check_marker(gb, "before fixed_vop_rate"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5545 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5546 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ |
2637 | 5547 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits); |
5548 }else | |
5549 s->avctx->time_base.num = 1; | |
5550 | |
2034 | 5551 s->t_frame=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5552 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5553 if (s->shape != BIN_ONLY_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5554 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5555 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5556 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5557 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5558 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5559 skip_bits1(gb); /* marker */ |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
5560 if(width && height && !(s->width && s->codec_tag == ff_get_fourcc("MP4S"))){ /* they should be non zero but who knows ... */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5561 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5562 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5563 // printf("width/height: %d %d\n", width, height); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5564 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5565 } |
2967 | 5566 |
5567 s->progressive_sequence= | |
1659 | 5568 s->progressive_frame= get_bits1(gb)^1; |
3192 | 5569 s->interlaced_dct=0; |
2967 | 5570 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
1644 | 5571 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5572 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5573 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5574 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5575 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5576 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5577 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5578 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5579 if(s->vol_sprite_usage==STATIC_SPRITE){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5580 s->sprite_width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5581 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5582 s->sprite_height= get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5583 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5584 s->sprite_left = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5585 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5586 s->sprite_top = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5587 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5588 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5589 s->num_sprite_warping_points= get_bits(gb, 6); |
4930
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5590 if(s->num_sprite_warping_points > 3){ |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5591 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points); |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5592 s->num_sprite_warping_points= 0; |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5593 return -1; |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5594 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5595 s->sprite_warping_accuracy = get_bits(gb, 2); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5596 s->sprite_brightness_change= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5597 if(s->vol_sprite_usage==STATIC_SPRITE) |
2967 | 5598 s->low_latency_sprite= get_bits1(gb); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5599 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5600 // FIXME sadct disable bit if verid!=1 && shape not rect |
2967 | 5601 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5602 if (get_bits1(gb) == 1) { /* not_8_bit */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5603 s->quant_precision = get_bits(gb, 4); /* quant_precision */ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5604 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */ |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5605 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5606 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5607 s->quant_precision = 5; |
0 | 5608 } |
2967 | 5609 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5610 // FIXME a bunch of grayscale shape things |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5611 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5612 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 5613 int i, v; |
2967 | 5614 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5615 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5616 for(i=0; i<64; i++){ |
1092 | 5617 int j= s->dsp.idct_permutation[i]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5618 v= ff_mpeg4_default_intra_matrix[i]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5619 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5620 s->chroma_intra_matrix[j]= v; |
2967 | 5621 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5622 v= ff_mpeg4_default_non_intra_matrix[i]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5623 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5624 s->chroma_inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5625 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5626 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5627 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5628 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5629 int last=0; |
2979 | 5630 for(i=0; i<64; i++){ |
1057 | 5631 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5632 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5633 if(v==0) break; |
2967 | 5634 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5635 last= v; |
1092 | 5636 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5637 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5638 s->chroma_intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5639 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5640 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5641 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5642 for(; i<64; i++){ |
2979 | 5643 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
1411 | 5644 s->intra_matrix[j]= last; |
5645 s->chroma_intra_matrix[j]= last; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5646 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5647 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5648 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5649 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5650 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5651 int last=0; |
2979 | 5652 for(i=0; i<64; i++){ |
1057 | 5653 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5654 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5655 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5656 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5657 last= v; |
1092 | 5658 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5659 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5660 s->chroma_inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5661 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5662 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5663 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5664 for(; i<64; i++){ |
2979 | 5665 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5666 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5667 s->chroma_inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5668 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5669 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5670 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5671 // FIXME a bunch of grayscale shape things |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5672 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5673 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5674 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5675 s->quarter_sample= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5676 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5677 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5678 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5679 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5680 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5681 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5682 s->data_partitioning= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5683 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5684 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5685 } |
2967 | 5686 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5687 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5688 s->new_pred= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5689 if(s->new_pred){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5690 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5691 skip_bits(gb, 2); /* requested upstream message type */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5692 skip_bits1(gb); /* newpred segment type */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5693 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5694 s->reduced_res_vop= get_bits1(gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5695 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5696 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5697 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5698 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5699 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5700 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5701 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5702 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5703 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5704 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5705 GetBitContext bak= *gb; |
751 | 5706 int ref_layer_id; |
5707 int ref_layer_sampling_dir; | |
5708 int h_sampling_factor_n; | |
5709 int h_sampling_factor_m; | |
5710 int v_sampling_factor_n; | |
5711 int v_sampling_factor_m; | |
2967 | 5712 |
751 | 5713 s->hierachy_type= get_bits1(gb); |
5714 ref_layer_id= get_bits(gb, 4); | |
5715 ref_layer_sampling_dir= get_bits1(gb); | |
5716 h_sampling_factor_n= get_bits(gb, 5); | |
5717 h_sampling_factor_m= get_bits(gb, 5); | |
5718 v_sampling_factor_n= get_bits(gb, 5); | |
5719 v_sampling_factor_m= get_bits(gb, 5); | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5720 s->enhancement_type= get_bits1(gb); |
2967 | 5721 |
5722 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5723 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ |
2967 | 5724 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5725 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5726 s->scalability=0; |
2967 | 5727 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5728 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5729 }else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5730 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); |
2967 | 5731 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5732 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5733 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5734 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5735 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5736 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5737 |
1034 | 5738 /** |
5739 * decodes the user data stuff in the header. | |
5740 * allso inits divx/xvid/lavc_version/build | |
5741 */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5742 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5743 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5744 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5745 int e; |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5746 int ver = 0, build = 0, ver2 = 0, ver3 = 0; |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
5747 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5748 |
3615 | 5749 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){ |
2804 | 5750 if(show_bits(gb, 23) == 0) break; |
5751 buf[i]= get_bits(gb, 8); | |
5752 } | |
5753 buf[i]=0; | |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
5754 |
761 | 5755 /* divx detection */ |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
5756 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last); |
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
5757 if(e<2) |
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
5758 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last); |
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
5759 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5760 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5761 s->divx_build= build; |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
5762 s->divx_packed= e==3 && last=='p'; |
0 | 5763 } |
2967 | 5764 |
761 | 5765 /* ffmpeg detection */ |
2805
55a6659fc2ee
fix user data parsing code so it suppors pre1 and cvs
michael
parents:
2804
diff
changeset
|
5766 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5767 if(e!=4) |
2967 | 5768 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5769 if(e!=4){ |
2814 | 5770 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1; |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5771 if (e>1) |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5772 build= (ver<<16) + (ver2<<8) + ver3; |
2814 | 5773 } |
5774 if(e!=4){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5775 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5776 s->lavc_build= 4600; |
63 | 5777 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5778 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5779 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5780 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5781 } |
2967 | 5782 |
761 | 5783 /* xvid detection */ |
5784 e=sscanf(buf, "XviD%d", &build); | |
5785 if(e==1){ | |
5786 s->xvid_build= build; | |
5787 } | |
5788 | |
255 | 5789 //printf("User Data: %s\n", buf); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5790 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5791 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5792 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5793 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5794 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5795 |
2979 | 5796 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ |
1346 | 5797 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5798 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n"); |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5799 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5800 } |
2967 | 5801 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5802 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5803 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5804 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5805 else |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
5806 s->decode_mb= ff_mpeg4_decode_mb; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5807 |
262 | 5808 time_incr=0; |
2967 | 5809 while (get_bits1(gb) != 0) |
0 | 5810 time_incr++; |
5811 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5812 check_marker(gb, "before time_increment"); |
2666 | 5813 |
5814 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5815 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n"); |
1068 | 5816 |
5817 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
5818 if(show_bits(gb, s->time_increment_bits+1)&1) break; | |
5819 } | |
1396 | 5820 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5821 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits); |
1068 | 5822 } |
2967 | 5823 |
1411 | 5824 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further |
5825 else time_increment= get_bits(gb, s->time_increment_bits); | |
2967 | 5826 |
1411 | 5827 // printf("%d %X\n", s->time_increment_bits, time_increment); |
2034 | 5828 //av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame); |
262 | 5829 if(s->pict_type!=B_TYPE){ |
324 | 5830 s->last_time_base= s->time_base; |
262 | 5831 s->time_base+= time_incr; |
2637 | 5832 s->time= s->time_base*s->avctx->time_base.den + time_increment; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5833 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5834 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5835 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n"); |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5836 s->time_base++; |
2637 | 5837 s->time+= s->avctx->time_base.den; |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5838 } |
664 | 5839 } |
324 | 5840 s->pp_time= s->time - s->last_non_b_time; |
5841 s->last_non_b_time= s->time; | |
262 | 5842 }else{ |
2637 | 5843 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment; |
664 | 5844 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
5845 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5846 // printf("messed up order, maybe after seeking? skipping current b frame\n"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5847 return FRAME_SKIPPED; |
335 | 5848 } |
3247 | 5849 ff_mpeg4_init_direct_mv(s); |
2967 | 5850 |
2034 | 5851 if(s->t_frame==0) s->t_frame= s->pb_time; |
664 | 5852 if(s->t_frame==0) s->t_frame=1; // 1/0 protection |
2967 | 5853 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) |
664 | 5854 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
2967 | 5855 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) |
664 | 5856 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
4346 | 5857 if(!s->progressive_sequence){ |
5858 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) | |
5859 return FRAME_SKIPPED; | |
5860 } | |
262 | 5861 } |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4001
diff
changeset
|
5862 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %"PRId64" last_base %d time %"PRId64" pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time); |
2967 | 5863 |
2813
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5864 if(s->avctx->time_base.num) |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5865 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num; |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5866 else |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5867 s->current_picture_ptr->pts= AV_NOPTS_VALUE; |
942 | 5868 if(s->avctx->debug&FF_DEBUG_PTS) |
2962 | 5869 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts); |
2034 | 5870 |
1068 | 5871 check_marker(gb, "before vop_coded"); |
2967 | 5872 |
0 | 5873 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5874 if (get_bits1(gb) != 1){ |
2271 | 5875 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
5876 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n"); | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5877 return FRAME_SKIPPED; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5878 } |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4001
diff
changeset
|
5879 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base, |
2967 | 5880 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5881 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5882 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { |
0 | 5883 /* rounding type for motion estimation */ |
2979 | 5884 s->no_rounding = get_bits1(gb); |
63 | 5885 } else { |
2979 | 5886 s->no_rounding = 0; |
0 | 5887 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5888 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5889 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5890 if (s->shape != RECT_SHAPE) { |
63 | 5891 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { |
5892 int width, height, hor_spat_ref, ver_spat_ref; | |
2967 | 5893 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5894 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5895 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5896 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5897 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5898 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5899 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5900 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 5901 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5902 skip_bits1(gb); /* change_CR_disable */ |
2967 | 5903 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5904 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5905 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 5906 } |
5907 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5908 //FIXME complexity estimation stuff |
2967 | 5909 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5910 if (s->shape != BIN_ONLY_SHAPE) { |
1520 | 5911 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ]; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
5912 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5913 s->top_field_first= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5914 s->alternate_scan= get_bits1(gb); |
661 | 5915 }else |
5916 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5917 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5918 |
718 | 5919 if(s->alternate_scan){ |
1273 | 5920 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
5921 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
5922 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
5923 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5924 } else{ |
1273 | 5925 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
5926 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
5927 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
5928 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5929 } |
2967 | 5930 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5931 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
1914 | 5932 mpeg4_decode_sprite_trajectory(s, gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5933 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5934 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n"); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5935 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5936 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5937 if (s->shape != BIN_ONLY_SHAPE) { |
1644 | 5938 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5939 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5940 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n"); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5941 return -1; // makes no sense to continue, as there is nothing left from the image then |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5942 } |
2967 | 5943 |
63 | 5944 if (s->pict_type != I_TYPE) { |
2979 | 5945 s->f_code = get_bits(gb, 3); /* fcode_for */ |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5946 if(s->f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5947 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n"); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5948 return -1; // makes no sense to continue, as the MV decoding will break very quickly |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5949 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5950 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5951 s->f_code=1; |
2967 | 5952 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5953 if (s->pict_type == B_TYPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5954 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5955 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5956 s->b_code=1; |
906 | 5957 |
5958 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
2967 | 5959 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d\n", |
5960 s->qscale, s->f_code, s->b_code, | |
5961 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), | |
5962 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, | |
930 | 5963 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, |
2967 | 5964 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold); |
906 | 5965 } |
5966 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5967 if(!s->scalability){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5968 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5969 skip_bits1(gb); // vop shape coding type |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5970 } |
575 | 5971 }else{ |
5972 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5973 int load_backward_shape= get_bits1(gb); |
575 | 5974 if(load_backward_shape){ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5975 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n"); |
575 | 5976 } |
5977 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5978 skip_bits(gb, 2); //ref_select_code |
63 | 5979 } |
5980 } | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5981 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/ |
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5982 // note we cannot detect divx5 without b-frames easily (although it's buggy too) |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5983 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5984 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n"); |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5985 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5986 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5987 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5988 s->picture_number++; // better than pic number==0 always ;) |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5989 |
2967 | 5990 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
498 | 5991 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; |
5992 | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1364
diff
changeset
|
5993 if(s->workaround_bugs&FF_BUG_EDGE){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5994 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5995 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5996 } |
63 | 5997 return 0; |
0 | 5998 } |
5999 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6000 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6001 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6002 * @return <0 if no VOP found (or a damaged one) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6003 * FRAME_SKIPPED if a not coded VOP is found |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6004 * 0 if a VOP is found |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6005 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6006 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6007 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6008 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6009 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6010 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6011 align_get_bits(gb); |
2406 | 6012 |
4155
0f28fc219799
add codec_tag and codec_stream_tag to MpegEncContext to not alter avctx values
bcoudurier
parents:
4122
diff
changeset
|
6013 if(s->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){ |
2406 | 6014 skip_bits(gb, 24); |
6015 if(get_bits(gb, 8) == 0xF0) | |
6016 return decode_vop_header(s, gb); | |
6017 } | |
6018 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6019 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6020 for(;;) { |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
6021 if(get_bits_count(gb) >= gb->size_in_bits){ |
2554
84a8f374bf63
fixing playback of xvid pretending to be divx (sample_vop_nc.avi)
michael
parents:
2522
diff
changeset
|
6022 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6023 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits); |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6024 return FRAME_SKIPPED; //divx bug |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6025 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6026 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6027 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6028 |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6029 /* use the bits after the test */ |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6030 v = get_bits(gb, 8); |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6031 startcode = ((startcode << 8) | v) & 0xffffffff; |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6032 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6033 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6034 continue; //no startcode |
2967 | 6035 |
942 | 6036 if(s->avctx->debug&FF_DEBUG_STARTCODE){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6037 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6038 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6039 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6040 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6041 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6042 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6043 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6044 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6045 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6046 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6047 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6048 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6049 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6050 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6051 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6052 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6053 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6054 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6055 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6056 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start"); |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6057 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6058 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6059 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6060 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6061 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start"); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6062 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6063 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6064 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6065 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb)); |
942 | 6066 } |
6067 | |
1512 | 6068 if(startcode >= 0x120 && startcode <= 0x12F){ |
2967 | 6069 if(decode_vol_header(s, gb) < 0) |
1396 | 6070 return -1; |
1512 | 6071 } |
6072 else if(startcode == USER_DATA_STARTCODE){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6073 decode_user_data(s, gb); |
1512 | 6074 } |
6075 else if(startcode == GOP_STARTCODE){ | |
942 | 6076 mpeg4_decode_gop_header(s, gb); |
1512 | 6077 } |
6078 else if(startcode == VOP_STARTCODE){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6079 return decode_vop_header(s, gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6080 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6081 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6082 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6083 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6084 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6085 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6086 |
0 | 6087 /* don't understand why they choose a different header ! */ |
6088 int intel_h263_decode_picture_header(MpegEncContext *s) | |
6089 { | |
6090 int format; | |
6091 | |
6092 /* picture header */ | |
1257 | 6093 if (get_bits_long(&s->gb, 22) != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6094 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 6095 return -1; |
355 | 6096 } |
6097 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 6098 |
355 | 6099 if (get_bits1(&s->gb) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6100 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
2979 | 6101 return -1; /* marker */ |
355 | 6102 } |
6103 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6104 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 6105 return -1; /* h263 id */ |
6106 } | |
6107 skip_bits1(&s->gb); /* split screen off */ | |
6108 skip_bits1(&s->gb); /* camera off */ | |
6109 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 6110 |
6111 format = get_bits(&s->gb, 3); | |
355 | 6112 if (format != 7) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6113 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); |
0 | 6114 return -1; |
355 | 6115 } |
0 | 6116 s->h263_plus = 0; |
6117 | |
21 | 6118 s->pict_type = I_TYPE + get_bits1(&s->gb); |
2967 | 6119 |
6120 s->unrestricted_mv = get_bits1(&s->gb); | |
0 | 6121 s->h263_long_vectors = s->unrestricted_mv; |
6122 | |
355 | 6123 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6124 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); |
2979 | 6125 return -1; /* SAC: off */ |
355 | 6126 } |
5405
f15e5b4909e1
remove "Advanced Prediction Mode not supported" spam
michael
parents:
5404
diff
changeset
|
6127 s->obmc= get_bits1(&s->gb); |
355 | 6128 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6129 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n"); |
2979 | 6130 return -1; /* PB frame mode */ |
355 | 6131 } |
0 | 6132 |
6133 /* skip unknown header garbage */ | |
21 | 6134 skip_bits(&s->gb, 41); |
0 | 6135 |
1644 | 6136 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 6137 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 6138 |
6139 /* PEI */ | |
21 | 6140 while (get_bits1(&s->gb) != 0) { |
6141 skip_bits(&s->gb, 8); | |
0 | 6142 } |
6143 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6144 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6145 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6146 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6147 |
5404 | 6148 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
6149 show_pict_info(s); | |
6150 | |
0 | 6151 return 0; |
6152 } | |
144 | 6153 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6154 int flv_h263_decode_picture_header(MpegEncContext *s) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6155 { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6156 int format, width, height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6157 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6158 /* picture header */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6159 if (get_bits_long(&s->gb, 17) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6160 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6161 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6162 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6163 format = get_bits(&s->gb, 5); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6164 if (format != 0 && format != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6165 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n"); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6166 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6167 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6168 s->h263_flv = format+1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6169 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6170 format = get_bits(&s->gb, 3); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6171 switch (format) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6172 case 0: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6173 width = get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6174 height = get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6175 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6176 case 1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6177 width = get_bits(&s->gb, 16); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6178 height = get_bits(&s->gb, 16); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6179 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6180 case 2: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6181 width = 352; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6182 height = 288; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6183 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6184 case 3: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6185 width = 176; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6186 height = 144; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6187 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6188 case 4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6189 width = 128; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6190 height = 96; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6191 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6192 case 5: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6193 width = 320; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6194 height = 240; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6195 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6196 case 6: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6197 width = 160; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6198 height = 120; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6199 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6200 default: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6201 width = height = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6202 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6203 } |
2422 | 6204 if(avcodec_check_dimensions(s->avctx, width, height)) |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6205 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6206 s->width = width; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6207 s->height = height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6208 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6209 s->pict_type = I_TYPE + get_bits(&s->gb, 2); |
1944 | 6210 s->dropable= s->pict_type > P_TYPE; |
6211 if (s->dropable) | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6212 s->pict_type = P_TYPE; |
2967 | 6213 |
2979 | 6214 skip_bits1(&s->gb); /* deblocking flag */ |
1644 | 6215 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6216 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6217 s->h263_plus = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6218 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6219 s->unrestricted_mv = 1; |
1364 | 6220 s->h263_long_vectors = 0; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6221 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6222 /* PEI */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6223 while (get_bits1(&s->gb) != 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6224 skip_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6225 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6226 s->f_code = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6227 |
1364 | 6228 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6229 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n", |
2414
18d77621fbc7
print "D" instead of "P" for dropable frames in flv with -debug 1
michael
parents:
2406
diff
changeset
|
6230 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); |
1364 | 6231 } |
2967 | 6232 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6233 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6234 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6235 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6236 return 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6237 } |