Mercurial > libavcodec.hg
annotate h263.c @ 1350:e7c8051e1849 libavcodec
the reference sw doesnt like some legal headers ...
author | michaelni |
---|---|
date | Mon, 07 Jul 2003 20:17:44 +0000 |
parents | 44c94325810c |
children | cfc80b3a4ada |
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. |
6 * | |
429 | 7 * This library is free software; you can redistribute it and/or |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2 of the License, or (at your option) any later version. | |
0 | 11 * |
429 | 12 * This library is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
429 | 17 * You should have received a copy of the GNU Lesser General Public |
18 * License along with this library; if not, write to the Free Software | |
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
20 * |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
21 * ac prediction encoding, b-frame support, error resilience, optimizations, |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
22 * qpel decoding, gmc decoding, interlaced decoding, |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
23 * by Michael Niedermayer <michaelni@gmx.at> |
0 | 24 */ |
1034 | 25 |
26 /** | |
27 * @file h263.c | |
1106 | 28 * h263/mpeg4 codec. |
1034 | 29 */ |
355 | 30 |
31 //#define DEBUG | |
0 | 32 #include "common.h" |
33 #include "dsputil.h" | |
34 #include "avcodec.h" | |
35 #include "mpegvideo.h" | |
36 #include "h263data.h" | |
37 #include "mpeg4data.h" | |
38 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
39 //#undef NDEBUG |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
40 //#include <assert.h> |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
41 |
544 | 42 #define INTRA_MCBPC_VLC_BITS 6 |
43 #define INTER_MCBPC_VLC_BITS 6 | |
44 #define CBPY_VLC_BITS 6 | |
45 #define MV_VLC_BITS 9 | |
46 #define DC_VLC_BITS 9 | |
47 #define SPRITE_TRAJ_VLC_BITS 6 | |
48 #define MB_TYPE_B_VLC_BITS 4 | |
49 #define TEX_VLC_BITS 9 | |
50 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
51 #ifdef CONFIG_ENCODERS |
0 | 52 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, |
53 int n); | |
324 | 54 static void h263_encode_motion(MpegEncContext * s, int val, int fcode); |
78 | 55 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
|
56 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
1064 | 57 int n, int dc, uint8_t *scan_table, |
453 | 58 PutBitContext *dc_pb, PutBitContext *ac_pb); |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
59 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
60 |
262 | 61 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 62 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 63 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
64 int n, int coded); | |
453 | 65 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
66 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 67 int n, int coded, int intra, int rvlc); |
1064 | 68 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr); |
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
|
69 #ifdef CONFIG_ENCODERS |
1008 | 70 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
71 int dir); |
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
|
72 #endif //CONFIG_ENCODERS |
290 | 73 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s); |
1064 | 74 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr); |
75 | |
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
|
76 #ifdef CONFIG_ENCODERS |
1064 | 77 static uint8_t uni_DCtab_lum_len[512]; |
78 static uint8_t uni_DCtab_chrom_len[512]; | |
79 static uint16_t uni_DCtab_lum_bits[512]; | |
80 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
|
81 |
1162 | 82 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL; |
1064 | 83 static uint8_t fcode_tab[MAX_MV*2+1]; |
84 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
|
85 |
945 | 86 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
87 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
88 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
89 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
90 //#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
|
91 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 92 #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
|
93 |
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
|
94 /* 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
|
95 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
|
96 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
|
97 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
|
98 |
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
|
99 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
|
100 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
|
101 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
|
102 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
103 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
104 |
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
|
105 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit |
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
|
106 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("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
|
107 #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
|
108 #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
|
109 #endif |
293 | 110 |
0 | 111 int h263_get_picture_format(int width, int height) |
112 { | |
113 int format; | |
114 | |
115 if (width == 128 && height == 96) | |
355 | 116 format = 1; |
0 | 117 else if (width == 176 && height == 144) |
355 | 118 format = 2; |
0 | 119 else if (width == 352 && height == 288) |
355 | 120 format = 3; |
0 | 121 else if (width == 704 && height == 576) |
355 | 122 format = 4; |
0 | 123 else if (width == 1408 && height == 1152) |
355 | 124 format = 5; |
0 | 125 else |
126 format = 7; | |
127 return format; | |
128 } | |
129 | |
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
|
130 #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
|
131 |
887 | 132 static void float_aspect_to_info(MpegEncContext * s, float aspect){ |
133 int i; | |
134 | |
135 aspect*= s->height/(double)s->width; | |
136 //printf("%f\n", aspect); | |
880 | 137 |
887 | 138 if(aspect==0) aspect= 1.0; |
139 | |
880 | 140 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255); |
887 | 141 |
142 //printf("%d %d\n", s->aspected_width, s->aspected_height); | |
143 for(i=1; i<6; i++){ | |
144 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){ | |
145 s->aspect_ratio_info=i; | |
146 return; | |
147 } | |
148 } | |
880 | 149 |
887 | 150 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 151 } |
152 | |
0 | 153 void h263_encode_picture_header(MpegEncContext * s, int picture_number) |
154 { | |
78 | 155 int format; |
0 | 156 |
157 align_put_bits(&s->pb); | |
231 | 158 |
159 /* 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
|
160 s->ptr_lastgob = pbBufPtr(&s->pb); |
231 | 161 s->gob_number = 0; |
162 | |
163 put_bits(&s->pb, 22, 0x20); /* PSC */ | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
164 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
165 s->avctx->frame_rate) & 0xff); |
0 | 166 |
167 put_bits(&s->pb, 1, 1); /* marker */ | |
168 put_bits(&s->pb, 1, 0); /* h263 id */ | |
169 put_bits(&s->pb, 1, 0); /* split screen off */ | |
170 put_bits(&s->pb, 1, 0); /* camera off */ | |
171 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
78 | 172 |
173 format = h263_get_picture_format(s->width, s->height); | |
0 | 174 if (!s->h263_plus) { |
175 /* H.263v1 */ | |
176 put_bits(&s->pb, 3, format); | |
177 put_bits(&s->pb, 1, (s->pict_type == P_TYPE)); | |
178 /* By now UMV IS DISABLED ON H.263v1, since the restrictions | |
179 of H.263v1 UMV implies to check the predicted MV after | |
180 calculation of the current MB to see if we're on the limits */ | |
181 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */ | |
182 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
183 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */ | |
184 put_bits(&s->pb, 1, 0); /* not PB frame */ | |
185 put_bits(&s->pb, 5, s->qscale); | |
186 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
187 } else { | |
188 /* H.263v2 */ | |
189 /* H.263 Plus PTYPE */ | |
190 put_bits(&s->pb, 3, 7); | |
191 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */ | |
78 | 192 if (format == 7) |
193 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
194 else | |
195 put_bits(&s->pb, 3, format); | |
196 | |
0 | 197 put_bits(&s->pb,1,0); /* Custom PCF: off */ |
1089 | 198 s->umvplus = s->unrestricted_mv; |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
199 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 200 put_bits(&s->pb,1,0); /* SAC: off */ |
201 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
202 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
0 | 203 put_bits(&s->pb,1,0); /* Deblocking Filter: off */ |
204 put_bits(&s->pb,1,0); /* Slice Structured: off */ | |
205 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ | |
206 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
207 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */ | |
208 put_bits(&s->pb,1,0); /* Modified Quantization: off */ | |
209 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
210 put_bits(&s->pb,3,0); /* Reserved */ | |
211 | |
212 put_bits(&s->pb, 3, s->pict_type == P_TYPE); | |
213 | |
214 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ | |
215 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
|
216 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 217 put_bits(&s->pb,2,0); /* Reserved */ |
218 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
219 | |
220 /* This should be here if PLUSPTYPE */ | |
221 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
222 | |
78 | 223 if (format == 7) { |
224 /* Custom Picture Format (CPFMT) */ | |
887 | 225 float_aspect_to_info(s, s->avctx->aspect_ratio); |
880 | 226 |
227 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 228 put_bits(&s->pb,9,(s->width >> 2) - 1); |
229 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
230 put_bits(&s->pb,9,(s->height >> 2)); | |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
231 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
232 { |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
233 put_bits(&s->pb, 8, s->aspected_width); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
234 put_bits(&s->pb, 8, s->aspected_height); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
235 } |
78 | 236 } |
237 | |
0 | 238 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
239 if (s->umvplus) |
1089 | 240 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
241 put_bits(&s->pb,2,1); /* unlimited */ | |
242 | |
0 | 243 put_bits(&s->pb, 5, s->qscale); |
244 } | |
245 | |
246 put_bits(&s->pb, 1, 0); /* no PEI */ | |
498 | 247 |
248 if(s->h263_aic){ | |
249 s->y_dc_scale_table= | |
250 s->c_dc_scale_table= h263_aic_dc_scale_table; | |
251 }else{ | |
252 s->y_dc_scale_table= | |
253 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
254 } | |
0 | 255 } |
256 | |
766 | 257 /** |
258 * Encodes a group of blocks header. | |
259 */ | |
162 | 260 int h263_encode_gob_header(MpegEncContext * s, int mb_line) |
261 { | |
262 align_put_bits(&s->pb); | |
231 | 263 flush_put_bits(&s->pb); |
264 /* Call the RTP callback to send the last GOB */ | |
265 if (s->rtp_callback) { | |
766 | 266 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 267 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number); |
268 } | |
162 | 269 put_bits(&s->pb, 17, 1); /* GBSC */ |
231 | 270 s->gob_number = mb_line / s->gob_index; |
162 | 271 put_bits(&s->pb, 5, s->gob_number); /* GN */ |
231 | 272 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ |
162 | 273 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
231 | 274 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif); |
766 | 275 return 0; |
162 | 276 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
277 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
278 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6]) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
279 { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
280 int score0=0, score1=0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
281 int i, n; |
903 | 282 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
|
283 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
284 for(n=0; n<6; n++){ |
1064 | 285 int16_t *ac_val, *ac_val1; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
286 |
266 | 287 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
|
288 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
289 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
|
290 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
|
291 /* top prediction */ |
266 | 292 ac_val-= s->block_wrap[n]*16; |
903 | 293 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
|
294 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
295 for(i=1; i<8; i++){ |
1092 | 296 const int level= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
297 score0+= ABS(level); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
298 score1+= ABS(level - ac_val[i+8]); |
1092 | 299 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
|
300 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
301 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
302 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
303 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
304 for(i=1; i<8; i++){ |
1092 | 305 const int level= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
306 score0+= ABS(level); |
903 | 307 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale)); |
1092 | 308 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
|
309 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
310 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
311 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
312 }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
|
313 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
|
314 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
315 ac_val-= 16; |
903 | 316 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
|
317 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
318 for(i=1; i<8; i++){ |
1092 | 319 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
320 score0+= ABS(level); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
321 score1+= ABS(level - ac_val[i]); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
322 ac_val1[i ]= level; |
1092 | 323 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
|
324 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
325 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
326 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
327 for(i=1; i<8; i++){ |
1092 | 328 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
329 score0+= ABS(level); |
903 | 330 score1+= ABS(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
|
331 ac_val1[i ]= level; |
1092 | 332 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
|
333 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
334 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
335 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
336 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
337 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
338 return score0 > score1 ? 1 : 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
339 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
340 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
341 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
342 * 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
|
343 */ |
695 | 344 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
345 int i; |
903 | 346 int8_t * const qscale_table= s->current_picture.qscale_table; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
347 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
348 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
|
349 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
|
350 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
|
351 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
352 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
|
353 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
|
354 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
|
355 } |
695 | 356 } |
357 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
358 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
359 * 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
|
360 */ |
695 | 361 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
362 int i; | |
903 | 363 int8_t * const qscale_table= s->current_picture.qscale_table; |
364 | |
695 | 365 ff_clean_h263_qscales(s); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
366 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
367 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
|
368 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
|
369 |
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
|
370 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){ |
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
|
371 s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V; |
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
|
372 s->mb_type[mb_xy]|= MB_TYPE_INTER; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
373 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
374 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
375 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
376 if(s->pict_type== B_TYPE){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
377 int odd=0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
378 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
379 for the actual adaptive quantization */ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
380 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
381 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
|
382 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
|
383 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
384 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
385 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
386 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
387 else odd=0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
388 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
389 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
|
390 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
|
391 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
|
392 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
|
393 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
|
394 qscale_table[mb_xy]= 31; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
395 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
396 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
397 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
|
398 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
|
399 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){ |
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
|
400 s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT; |
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
|
401 s->mb_type[mb_xy]|= MB_TYPE_BIDIR; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
402 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
403 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
404 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
405 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
406 |
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
|
407 #endif //CONFIG_ENCODERS |
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
|
408 /** |
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
|
409 * |
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
|
410 * @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
|
411 */ |
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
|
412 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
|
413 const int mb_index= 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
|
414 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next? |
936 | 415 int xy= s->block_index[0]; |
416 uint16_t time_pp= s->pp_time; | |
417 uint16_t time_pb= s->pb_time; | |
418 int i; | |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1042
diff
changeset
|
419 |
936 | 420 //FIXME avoid divides |
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
|
421 |
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
|
422 if(IS_8X8(colocated_mb_type)){ |
936 | 423 s->mv_type = MV_TYPE_8X8; |
424 for(i=0; i<4; i++){ | |
425 xy= s->block_index[i]; | |
426 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx; | |
427 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my; | |
428 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0] | |
429 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp; | |
430 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] | |
431 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp; | |
432 } | |
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
|
433 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
|
434 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 435 s->mv_type = MV_TYPE_FIELD; |
436 for(i=0; i<2; i++){ | |
437 if(s->top_field_first){ | |
438 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i; | |
439 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i; | |
440 }else{ | |
441 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i; | |
442 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i; | |
443 } | |
444 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx; | |
445 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my; | |
446 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0] | |
447 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp; | |
448 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] | |
449 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp; | |
450 } | |
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 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
|
452 }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
|
453 s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx; |
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
|
454 s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + 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
|
455 s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][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
|
456 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp; |
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
|
457 s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][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
|
458 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp; |
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
|
459 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
|
460 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
|
461 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
|
462 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
|
463 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 464 } |
465 } | |
466 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
467 #ifdef CONFIG_ENCODERS |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
468 void mpeg4_encode_mb(MpegEncContext * s, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
469 DCTELEM block[6][64], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
470 int motion_x, int motion_y) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
471 { |
1057 | 472 int cbpc, cbpy, pred_x, pred_y; |
286 | 473 int bits; |
453 | 474 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
475 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb; | |
476 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb; | |
477 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
|
478 const int dquant_code[5]= {1,0,9,2,3}; |
162 | 479 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
480 // 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
|
481 if (!s->mb_intra) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
482 /* compute cbp */ |
1057 | 483 int i, cbp = 0; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
484 for (i = 0; i < 6; i++) { |
324 | 485 if (s->block_last_index[i] >= 0) |
486 cbp |= 1 << (5 - i); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
487 } |
324 | 488 |
489 if(s->pict_type==B_TYPE){ | |
490 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ | |
491 int mb_type= mb_type_table[s->mv_dir]; | |
492 | |
493 if(s->mb_x==0){ | |
494 s->last_mv[0][0][0]= | |
495 s->last_mv[0][0][1]= | |
496 s->last_mv[1][0][0]= | |
497 s->last_mv[1][0][1]= 0; | |
498 } | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
499 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
500 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
501 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
502 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
503 |
324 | 504 /* nothing to do if this MB was skiped 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
|
505 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 506 s->skip_count++; |
507 s->mv[0][0][0]= | |
508 s->mv[0][0][1]= | |
509 s->mv[1][0][0]= | |
510 s->mv[1][0][1]= 0; | |
327 | 511 s->mv_dir= MV_DIR_FORWARD; //doesnt matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
512 s->qscale -= s->dquant; |
903 | 513 // s->mb_skiped=1; |
514 | |
324 | 515 return; |
516 } | |
936 | 517 |
324 | 518 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
519 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
520 assert(s->dquant==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
521 |
324 | 522 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 523 |
524 if(interleaved_stats){ | |
525 s->misc_bits++; | |
526 s->last_bits++; | |
527 } | |
324 | 528 s->skip_count++; |
529 return; | |
530 } | |
903 | 531 |
324 | 532 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
533 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge | |
534 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :) | |
535 if(cbp) put_bits(&s->pb, 6, cbp); | |
536 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
537 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
538 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
539 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
540 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
541 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
542 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
543 s->qscale -= s->dquant; |
697 | 544 |
545 if(!s->progressive_sequence){ | |
546 if(cbp) | |
547 put_bits(&s->pb, 1, s->interlaced_dct); | |
548 if(mb_type) // not diect mode | |
549 put_bits(&s->pb, 1, 0); // no interlaced ME yet | |
550 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
551 |
453 | 552 if(interleaved_stats){ |
1164 | 553 s->misc_bits+= get_bits_diff(s); |
453 | 554 } |
295 | 555 |
324 | 556 switch(mb_type) |
557 { | |
558 case 0: /* direct */ | |
559 h263_encode_motion(s, motion_x, 1); | |
560 h263_encode_motion(s, motion_y, 1); | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
561 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
562 s->f_count++; |
324 | 563 break; |
564 case 1: /* bidir */ | |
565 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); | |
566 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
567 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); | |
568 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
569 s->last_mv[0][0][0]= s->mv[0][0][0]; | |
570 s->last_mv[0][0][1]= s->mv[0][0][1]; | |
571 s->last_mv[1][0][0]= s->mv[1][0][0]; | |
572 s->last_mv[1][0][1]= s->mv[1][0][1]; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
573 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
574 s->f_count++; |
324 | 575 break; |
576 case 2: /* backward */ | |
577 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); | |
578 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); | |
579 s->last_mv[1][0][0]= motion_x; | |
580 s->last_mv[1][0][1]= motion_y; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
581 s->b_count++; |
324 | 582 break; |
583 case 3: /* forward */ | |
584 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); | |
585 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); | |
586 s->last_mv[0][0][0]= motion_x; | |
587 s->last_mv[0][0][1]= motion_y; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
588 s->f_count++; |
324 | 589 break; |
327 | 590 default: |
591 printf("unknown mb type\n"); | |
324 | 592 return; |
593 } | |
453 | 594 |
595 if(interleaved_stats){ | |
1164 | 596 s->mv_bits+= get_bits_diff(s); |
453 | 597 } |
295 | 598 |
324 | 599 /* encode each block */ |
600 for (i = 0; i < 6; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
601 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb); |
324 | 602 } |
453 | 603 |
604 if(interleaved_stats){ | |
1164 | 605 s->p_tex_bits+= get_bits_diff(s); |
453 | 606 } |
324 | 607 }else{ /* s->pict_type==B_TYPE */ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
608 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
331 | 609 /* check if the B frames can skip it too, as we must skip it if we skip here |
610 why didnt they just compress the skip-mb bits instead of reusing them ?! */ | |
611 if(s->max_b_frames>0){ | |
612 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
613 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
614 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
615 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
616 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
617 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
618 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
|
619 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
|
620 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
621 offset= x + y*s->linesize; |
903 | 622 p_pic= s->new_picture.data[0] + offset; |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
623 |
331 | 624 s->mb_skiped=1; |
625 for(i=0; i<s->max_b_frames; i++){ | |
339 | 626 uint8_t *b_pic; |
627 int diff; | |
903 | 628 Picture *pic= s->reordered_input_picture[i+1]; |
629 | |
630 if(pic==NULL || pic->pict_type!=B_TYPE) break; | |
631 | |
632 b_pic= pic->data[0] + offset + 16; //FIXME +16 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
633 diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize); |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
634 if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
331 | 635 s->mb_skiped=0; |
636 break; | |
637 } | |
638 } | |
639 }else | |
640 s->mb_skiped=1; | |
641 | |
642 if(s->mb_skiped==1){ | |
643 /* skip macroblock */ | |
644 put_bits(&s->pb, 1, 1); | |
453 | 645 |
646 if(interleaved_stats){ | |
647 s->misc_bits++; | |
648 s->last_bits++; | |
649 } | |
331 | 650 s->skip_count++; |
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
|
651 |
331 | 652 return; |
653 } | |
295 | 654 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
655 |
324 | 656 put_bits(&s->pb, 1, 0); /* mb coded */ |
657 if(s->mv_type==MV_TYPE_16X16){ | |
658 cbpc = cbp & 3; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
659 if(s->dquant) cbpc+= 8; |
324 | 660 put_bits(&s->pb, |
661 inter_MCBPC_bits[cbpc], | |
662 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
663 |
324 | 664 cbpy = cbp >> 2; |
665 cbpy ^= 0xf; | |
453 | 666 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
|
667 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
668 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 669 |
670 if(!s->progressive_sequence){ | |
671 if(cbp) | |
672 put_bits(pb2, 1, s->interlaced_dct); | |
673 put_bits(pb2, 1, 0); // no interlaced ME yet | |
674 } | |
324 | 675 |
453 | 676 if(interleaved_stats){ |
1164 | 677 s->misc_bits+= get_bits_diff(s); |
453 | 678 } |
324 | 679 |
680 /* motion vectors: 16x16 mode */ | |
681 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
682 | |
683 h263_encode_motion(s, motion_x - pred_x, s->f_code); | |
684 h263_encode_motion(s, motion_y - pred_y, s->f_code); | |
685 }else{ | |
686 cbpc = (cbp & 3)+16; | |
687 put_bits(&s->pb, | |
688 inter_MCBPC_bits[cbpc], | |
689 inter_MCBPC_code[cbpc]); | |
690 cbpy = cbp >> 2; | |
691 cbpy ^= 0xf; | |
453 | 692 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
693 | |
757 | 694 if(!s->progressive_sequence){ |
695 if(cbp) | |
696 put_bits(pb2, 1, s->interlaced_dct); | |
697 } | |
698 | |
453 | 699 if(interleaved_stats){ |
1164 | 700 s->misc_bits+= get_bits_diff(s); |
453 | 701 } |
324 | 702 |
703 for(i=0; i<4; i++){ | |
704 /* motion vectors: 8x8 mode*/ | |
705 h263_pred_motion(s, i, &pred_x, &pred_y); | |
706 | |
707 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code); | |
708 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code); | |
709 } | |
710 } | |
453 | 711 |
712 if(interleaved_stats){ | |
1164 | 713 s->mv_bits+= get_bits_diff(s); |
453 | 714 } |
324 | 715 |
716 /* encode each block */ | |
717 for (i = 0; i < 6; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
718 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb); |
324 | 719 } |
453 | 720 |
721 if(interleaved_stats){ | |
1164 | 722 s->p_tex_bits+= get_bits_diff(s); |
453 | 723 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
724 s->f_count++; |
295 | 725 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
726 } else { |
324 | 727 int cbp; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
728 int dc_diff[6]; //dc values with the dc prediction subtracted |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
729 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
730 int zigzag_last_index[6]; |
1064 | 731 uint8_t *scan_table[6]; |
1057 | 732 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
733 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
734 for(i=0; i<6; i++){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
735 const int level= block[i][0]; |
1064 | 736 uint16_t *dc_ptr; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
737 |
498 | 738 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
739 if (i < 4) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
740 *dc_ptr = level * s->y_dc_scale; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
741 } else { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
742 *dc_ptr = level * s->c_dc_scale; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
743 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
744 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
745 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
746 s->ac_pred= decide_ac_pred(s, block, dir); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
747 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
748 if(s->ac_pred){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
749 for(i=0; i<6; i++){ |
1064 | 750 uint8_t *st; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
751 int last_index; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
752 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
753 mpeg4_inv_pred_ac(s, block[i], i, dir[i]); |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
754 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
755 else st = s->intra_h_scantable.permutated; /* top */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
756 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
757 for(last_index=63; last_index>=0; last_index--) //FIXME optimize |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
758 if(block[i][st[last_index]]) break; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
759 zigzag_last_index[i]= s->block_last_index[i]; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
760 s->block_last_index[i]= last_index; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
761 scan_table[i]= st; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
762 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
763 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
764 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
765 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
|
766 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
767 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
768 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
769 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
770 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
771 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
772 cbp |= 1 << (5 - i); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
773 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
774 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
775 cbpc = cbp & 3; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
776 if (s->pict_type == I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
777 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
778 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
779 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
780 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
781 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
782 if(s->dquant) cbpc+=8; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
783 put_bits(&s->pb, 1, 0); /* mb coded */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
784 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
785 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
786 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
787 } |
453 | 788 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
|
789 cbpy = cbp >> 2; |
453 | 790 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
|
791 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
792 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 793 |
697 | 794 if(!s->progressive_sequence){ |
795 put_bits(dc_pb, 1, s->interlaced_dct); | |
796 } | |
797 | |
453 | 798 if(interleaved_stats){ |
1164 | 799 s->misc_bits+= get_bits_diff(s); |
453 | 800 } |
286 | 801 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
802 /* encode each block */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
803 for (i = 0; i < 6; i++) { |
453 | 804 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
805 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
806 |
453 | 807 if(interleaved_stats){ |
1164 | 808 s->i_tex_bits+= get_bits_diff(s); |
453 | 809 } |
286 | 810 s->i_count++; |
811 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
812 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
813 if(s->ac_pred){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
814 for(i=0; i<6; i++){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
815 int j; |
1064 | 816 int16_t *ac_val; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
817 |
266 | 818 ac_val = s->ac_val[0][0] + s->block_index[i] * 16; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
819 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
820 if(dir[i]){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
821 for(j=1; j<8; j++) |
1092 | 822 block[i][s->dsp.idct_permutation[j ]]= ac_val[j+8]; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
823 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
824 for(j=1; j<8; j++) |
1092 | 825 block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j ]; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
826 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
827 s->block_last_index[i]= zigzag_last_index[i]; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
828 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
829 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
830 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
831 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
832 |
0 | 833 void h263_encode_mb(MpegEncContext * s, |
834 DCTELEM block[6][64], | |
835 int motion_x, int motion_y) | |
836 { | |
837 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 838 int16_t pred_dc; |
839 int16_t rec_intradc[6]; | |
840 uint16_t *dc_ptr[6]; | |
695 | 841 const int dquant_code[5]= {1,0,9,2,3}; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
842 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
843 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
324 | 844 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
845 /* compute cbp */ |
324 | 846 cbp = 0; |
847 for (i = 0; i < 6; i++) { | |
848 if (s->block_last_index[i] >= 0) | |
849 cbp |= 1 << (5 - i); | |
850 } | |
695 | 851 if ((cbp | motion_x | motion_y | s->dquant) == 0) { |
324 | 852 /* skip macroblock */ |
853 put_bits(&s->pb, 1, 1); | |
854 return; | |
855 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
856 put_bits(&s->pb, 1, 0); /* mb coded */ |
324 | 857 cbpc = cbp & 3; |
695 | 858 if(s->dquant) cbpc+= 8; |
324 | 859 put_bits(&s->pb, |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
860 inter_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
861 inter_MCBPC_code[cbpc]); |
324 | 862 cbpy = cbp >> 2; |
863 cbpy ^= 0xf; | |
864 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
695 | 865 if(s->dquant) |
866 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
0 | 867 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
868 /* motion vectors: 16x16 mode only now */ |
324 | 869 h263_pred_motion(s, 0, &pred_x, &pred_y); |
78 | 870 |
324 | 871 if (!s->umvplus) { |
872 h263_encode_motion(s, motion_x - pred_x, s->f_code); | |
873 h263_encode_motion(s, motion_y - pred_y, s->f_code); | |
874 } | |
875 else { | |
876 h263p_encode_umotion(s, motion_x - pred_x); | |
877 h263p_encode_umotion(s, motion_y - pred_y); | |
878 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
879 /* To prevent Start Code emulation */ |
324 | 880 put_bits(&s->pb,1,1); |
881 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
882 } else { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
883 int li = s->h263_aic ? 0 : 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
884 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
885 cbp = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
886 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
|
887 /* Predict DC */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
888 if (s->h263_aic && s->mb_intra) { |
1064 | 889 int16_t level = block[i][0]; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
890 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
891 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
|
892 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
893 /* Quant */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
894 if (level < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
895 level = (level + (s->qscale >> 1))/(s->y_dc_scale); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
896 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
897 level = (level - (s->qscale >> 1))/(s->y_dc_scale); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
898 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
899 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
900 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
|
901 s->block_last_index[i] = -1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
902 else if (level < -127) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
903 level = -127; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
904 else if (level > 127) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
905 level = 127; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
906 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
907 block[i][0] = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
908 /* Reconstruction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
909 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
910 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
911 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
912 //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
|
913 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
914 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
915 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
916 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
917 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
|
918 rec_intradc[i] = 2047; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
919 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
920 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
921 *dc_ptr[i] = rec_intradc[i]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
922 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
923 /* compute cbp */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
924 if (s->block_last_index[i] >= li) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
925 cbp |= 1 << (5 - i); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
926 } |
0 | 927 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
928 cbpc = cbp & 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
929 if (s->pict_type == I_TYPE) { |
695 | 930 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
|
931 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
932 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
933 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
934 } else { |
695 | 935 if(s->dquant) cbpc+=8; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
936 put_bits(&s->pb, 1, 0); /* mb coded */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
937 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
938 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
939 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
940 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
941 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
942 /* XXX: currently, we do not try to use ac prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
943 put_bits(&s->pb, 1, 0); /* no AC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
944 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
945 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
946 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 947 if(s->dquant) |
948 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
0 | 949 } |
950 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
951 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
|
952 /* encode each block */ |
294 | 953 h263_encode_block(s, block[i], i); |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
954 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
955 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
956 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
|
957 block[i][0] = rec_intradc[i]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
958 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
959 } |
0 | 960 } |
961 } | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
962 #endif |
0 | 963 |
1064 | 964 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
965 { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
966 int x, y, wrap, a, c, pred_dc, scale; |
1064 | 967 int16_t *dc_val, *ac_val; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
968 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
969 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
970 if (n < 4) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
971 x = 2 * s->mb_x + 1 + (n & 1); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
972 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
973 wrap = s->mb_width * 2 + 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
974 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
|
975 ac_val = s->ac_val[0][0]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
976 scale = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
977 } else { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
978 x = s->mb_x + 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
979 y = s->mb_y + 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
980 wrap = s->mb_width + 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
981 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
|
982 ac_val = s->ac_val[n - 4 + 1][0]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
983 scale = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
984 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
985 /* B C |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
986 * A X |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
987 */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
988 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
|
989 c = dc_val[(x) + (y - 1) * wrap]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
990 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
991 /* No prediction outside GOB boundary */ |
453 | 992 if (s->first_slice_line && ((n < 2) || (n > 3))) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
993 c = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
994 pred_dc = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
995 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
996 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
997 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
998 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
999 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1000 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1001 pred_dc = c; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1002 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1003 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1004 //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
|
1005 *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
|
1006 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1007 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1008 |
1057 | 1009 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
|
1010 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1011 int x, y, wrap, a, c, pred_dc, scale, i; |
1064 | 1012 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1013 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1014 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1015 if (n < 4) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1016 x = 2 * s->mb_x + 1 + (n & 1); |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1017 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1018 wrap = s->mb_width * 2 + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1019 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1020 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1021 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1022 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1023 x = s->mb_x + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1024 y = s->mb_y + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1025 wrap = s->mb_width + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1026 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1027 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
|
1028 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1029 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1030 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1031 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1032 ac_val1 = ac_val; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1033 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1034 /* B C |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1035 * A X |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1036 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1037 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1038 c = dc_val[(x) + (y - 1) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1039 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1040 /* No prediction outside GOB boundary */ |
453 | 1041 if (s->first_slice_line && ((n < 2) || (n > 3))) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1042 c = 1024; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1043 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1044 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1045 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1046 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1047 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1048 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1049 for(i=1;i<8;i++) { |
1092 | 1050 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
|
1051 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1052 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1053 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1054 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1055 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1056 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1057 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1058 for(i=1;i<8;i++) { |
1092 | 1059 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
|
1060 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1061 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1062 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1063 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1064 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1065 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1066 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1067 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1068 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1069 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1070 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1071 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1072 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1073 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1074 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1075 block[0]=block[0]*scale + pred_dc; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1076 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1077 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1078 block[0] = 0; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1079 else if (!(block[0] & 1)) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1080 block[0]++; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1081 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1082 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1083 dc_val[(x) + (y) * wrap] = block[0]; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1084 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1085 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1086 for(i=1;i<8;i++) |
1092 | 1087 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
|
1088 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1089 for(i=1;i<8;i++) |
1092 | 1090 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
|
1091 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1092 |
1064 | 1093 int16_t *h263_pred_motion(MpegEncContext * s, int block, |
0 | 1094 int *px, int *py) |
1095 { | |
266 | 1096 int xy, wrap; |
1064 | 1097 int16_t *A, *B, *C, *mot_val; |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1098 static const int off[4]= {2, 1, 1, -1}; |
0 | 1099 |
266 | 1100 wrap = s->block_wrap[0]; |
1101 xy = s->block_index[block]; | |
0 | 1102 |
245 | 1103 mot_val = s->motion_val[xy]; |
0 | 1104 |
453 | 1105 A = s->motion_val[xy - 1]; |
1106 /* special case for first (slice) line */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1107 if (s->first_slice_line && block<3) { |
453 | 1108 // we cant just change some MVs to simulate that as we need them for the B frames (and ME) |
1109 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( | |
1110 if(block==0){ //most common case | |
1111 if(s->mb_x == s->resync_mb_x){ //rare | |
1112 *px= *py = 0; | |
1113 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare | |
1114 C = s->motion_val[xy + off[block] - wrap]; | |
1115 if(s->mb_x==0){ | |
1116 *px = C[0]; | |
1117 *py = C[1]; | |
1118 }else{ | |
1119 *px = mid_pred(A[0], 0, C[0]); | |
1120 *py = mid_pred(A[1], 0, C[1]); | |
1121 } | |
1122 }else{ | |
1123 *px = A[0]; | |
1124 *py = A[1]; | |
1125 } | |
1126 }else if(block==1){ | |
1127 if(s->mb_x + 1 == s->resync_mb_x){ //rare | |
1128 C = s->motion_val[xy + off[block] - wrap]; | |
1129 *px = mid_pred(A[0], 0, C[0]); | |
1130 *py = mid_pred(A[1], 0, C[1]); | |
1131 }else{ | |
1132 *px = A[0]; | |
1133 *py = A[1]; | |
1134 } | |
1135 }else{ /* block==2*/ | |
1136 B = s->motion_val[xy - wrap]; | |
1137 C = s->motion_val[xy + off[block] - wrap]; | |
1138 if(s->mb_x == s->resync_mb_x) //rare | |
1139 A[0]=A[1]=0; | |
1140 | |
1141 *px = mid_pred(A[0], B[0], C[0]); | |
1142 *py = mid_pred(A[1], B[1], C[1]); | |
1143 } | |
0 | 1144 } else { |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1145 B = s->motion_val[xy - wrap]; |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1146 C = s->motion_val[xy + off[block] - wrap]; |
0 | 1147 *px = mid_pred(A[0], B[0], C[0]); |
1148 *py = mid_pred(A[1], B[1], C[1]); | |
1149 } | |
1150 return mot_val; | |
1151 } | |
1152 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1153 #ifdef CONFIG_ENCODERS |
324 | 1154 static void h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1155 { |
702 | 1156 int range, l, bit_size, sign, code, bits; |
0 | 1157 |
1158 if (val == 0) { | |
1159 /* zero vector */ | |
1160 code = 0; | |
1161 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1162 } else { | |
324 | 1163 bit_size = f_code - 1; |
0 | 1164 range = 1 << bit_size; |
1165 /* modulo encoding */ | |
1166 l = range * 32; | |
702 | 1167 #if 1 |
1168 val+= l; | |
1169 val&= 2*l-1; | |
1170 val-= l; | |
1171 sign = val>>31; | |
1172 val= (val^sign)-sign; | |
1173 sign&=1; | |
1174 #else | |
0 | 1175 if (val < -l) { |
702 | 1176 val += 2*l; |
0 | 1177 } else if (val >= l) { |
702 | 1178 val -= 2*l; |
0 | 1179 } |
702 | 1180 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1181 assert(val>=-l && val<l); |
0 | 1182 |
1183 if (val >= 0) { | |
1184 sign = 0; | |
1185 } else { | |
1186 val = -val; | |
1187 sign = 1; | |
1188 } | |
702 | 1189 #endif |
312 | 1190 val--; |
1191 code = (val >> bit_size) + 1; | |
1192 bits = val & (range - 1); | |
0 | 1193 |
1194 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); | |
1195 if (bit_size > 0) { | |
1196 put_bits(&s->pb, bit_size, bits); | |
1197 } | |
1198 } | |
718 | 1199 |
0 | 1200 } |
1201 | |
78 | 1202 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1203 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1204 { | |
1205 short sval = 0; | |
1206 short i = 0; | |
1207 short n_bits = 0; | |
1208 short temp_val; | |
1209 int code = 0; | |
1210 int tcode; | |
1211 | |
1212 if ( val == 0) | |
1213 put_bits(&s->pb, 1, 1); | |
1214 else if (val == 1) | |
1215 put_bits(&s->pb, 3, 0); | |
1216 else if (val == -1) | |
1217 put_bits(&s->pb, 3, 2); | |
1218 else { | |
1219 | |
1220 sval = ((val < 0) ? (short)(-val):(short)val); | |
1221 temp_val = sval; | |
1222 | |
1223 while (temp_val != 0) { | |
1224 temp_val = temp_val >> 1; | |
1225 n_bits++; | |
1226 } | |
1227 | |
1228 i = n_bits - 1; | |
1229 while (i > 0) { | |
1230 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1231 tcode = (tcode << 1) | 1; | |
1232 code = (code << 2) | tcode; | |
1233 i--; | |
1234 } | |
1235 code = ((code << 1) | (val < 0)) << 1; | |
1236 put_bits(&s->pb, (2*n_bits)+1, code); | |
1237 //printf("\nVal = %d\tCode = %d", sval, code); | |
1238 } | |
1239 } | |
1240 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1241 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
|
1242 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1243 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1244 int mv; |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1245 |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1246 if(mv_penalty==NULL) |
1162 | 1247 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1248 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1249 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
|
1250 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
|
1251 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1252 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1253 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1254 else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1255 int val, bit_size, range, code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1256 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1257 bit_size = s->f_code - 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1258 range = 1 << bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1259 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1260 val=mv; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1261 if (val < 0) |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1262 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1263 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1264 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1265 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1266 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1267 }else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1268 len= mvtab[32][1] + 2 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1269 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1270 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1271 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1272 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
|
1273 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1274 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1275 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1276 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
|
1277 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
|
1278 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1279 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1280 } |
287 | 1281 |
1282 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1283 umv_fcode_tab[mv]= 1; | |
1284 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1285 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1286 #endif |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1287 |
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
|
1288 #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
|
1289 |
468 | 1290 static void init_uni_dc_tab(void) |
293 | 1291 { |
1292 int level, uni_code, uni_len; | |
1293 | |
312 | 1294 for(level=-256; level<256; level++){ |
293 | 1295 int size, v, l; |
1296 /* find number of bits */ | |
1297 size = 0; | |
1298 v = abs(level); | |
1299 while (v) { | |
1300 v >>= 1; | |
1301 size++; | |
1302 } | |
1303 | |
1304 if (level < 0) | |
1305 l= (-level) ^ ((1 << size) - 1); | |
1306 else | |
1307 l= level; | |
1308 | |
1309 /* luminance */ | |
1310 uni_code= DCtab_lum[size][0]; | |
1311 uni_len = DCtab_lum[size][1]; | |
1312 | |
1313 if (size > 0) { | |
1314 uni_code<<=size; uni_code|=l; | |
1315 uni_len+=size; | |
1316 if (size > 8){ | |
1317 uni_code<<=1; uni_code|=1; | |
1318 uni_len++; | |
1319 } | |
1320 } | |
1013 | 1321 uni_DCtab_lum_bits[level+256]= uni_code; |
1322 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1323 |
1324 /* chrominance */ | |
1325 uni_code= DCtab_chrom[size][0]; | |
1326 uni_len = DCtab_chrom[size][1]; | |
1327 | |
1328 if (size > 0) { | |
1329 uni_code<<=size; uni_code|=l; | |
1330 uni_len+=size; | |
1331 if (size > 8){ | |
1332 uni_code<<=1; uni_code|=1; | |
1333 uni_len++; | |
1334 } | |
1335 } | |
1013 | 1336 uni_DCtab_chrom_bits[level+256]= uni_code; |
1337 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1338 |
1339 } | |
1340 } | |
1341 | |
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
|
1342 #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
|
1343 |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1344 #ifdef CONFIG_ENCODERS |
1064 | 1345 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
|
1346 int slevel, run, 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
|
1347 |
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
|
1348 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
|
1349 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
|
1350 |
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
|
1351 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
|
1352 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
|
1353 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
|
1354 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
|
1355 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
|
1356 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
|
1357 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
|
1358 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
|
1359 int level1, run1; |
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
|
1360 |
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
|
1361 len_tab[index]= 100; |
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
|
1362 |
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
|
1363 /* 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
|
1364 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
|
1365 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
|
1366 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
|
1367 bits=bits*2+sign; 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
|
1368 |
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
|
1369 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
|
1370 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
|
1371 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
|
1372 } |
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
|
1373 #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
|
1374 /* 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
|
1375 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
|
1376 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
|
1377 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
|
1378 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
|
1379 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
|
1380 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
|
1381 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
|
1382 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
|
1383 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
|
1384 bits=bits*2+sign; 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
|
1385 |
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
|
1386 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
|
1387 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
|
1388 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
|
1389 } |
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
|
1390 } |
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
|
1391 #endif |
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
|
1392 #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
|
1393 /* 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
|
1394 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
|
1395 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
|
1396 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
|
1397 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
|
1398 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
|
1399 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
|
1400 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
|
1401 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
|
1402 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
|
1403 bits=bits*2+sign; 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
|
1404 |
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
|
1405 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
|
1406 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
|
1407 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
|
1408 } |
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
|
1409 } |
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
|
1410 #endif |
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
|
1411 /* 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
|
1412 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
|
1413 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
|
1414 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
|
1415 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
|
1416 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
|
1417 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
|
1418 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
|
1419 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
|
1420 |
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
|
1421 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
|
1422 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
|
1423 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
|
1424 } |
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
|
1425 } |
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
|
1426 } |
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
|
1427 } |
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
|
1428 } |
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
|
1429 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1430 void h263_encode_init(MpegEncContext *s) |
0 | 1431 { |
1432 static int done = 0; | |
1433 | |
1434 if (!done) { | |
1435 done = 1; | |
293 | 1436 |
1437 init_uni_dc_tab(); | |
1438 | |
0 | 1439 init_rl(&rl_inter); |
1440 init_rl(&rl_intra); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1441 init_rl(&rl_intra_aic); |
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
|
1442 |
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
|
1443 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
|
1444 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
|
1445 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1446 init_mv_penalty_and_fcode(s); |
0 | 1447 } |
936 | 1448 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1449 |
287 | 1450 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 1451 switch(s->codec_id){ |
1452 case CODEC_ID_MPEG4: | |
1453 s->fcode_tab= fcode_tab; | |
1454 s->min_qcoeff= -2048; | |
1455 s->max_qcoeff= 2047; | |
945 | 1456 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
1457 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
1458 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
1459 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 1460 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
1461 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 1462 s->ac_esc_length= 7+2+1+6+1+12+1; |
344 | 1463 break; |
1464 case CODEC_ID_H263P: | |
1465 s->fcode_tab= umv_fcode_tab; | |
1089 | 1466 s->min_qcoeff= -127; |
344 | 1467 s->max_qcoeff= 127; |
1468 break; | |
498 | 1469 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later |
344 | 1470 default: //nothing needed default table allready set in mpegvideo.c |
1089 | 1471 s->min_qcoeff= -127; |
344 | 1472 s->max_qcoeff= 127; |
498 | 1473 s->y_dc_scale_table= |
1474 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 1475 } |
0 | 1476 } |
1477 | |
1034 | 1478 /** |
1479 * encodes a 8x8 block. | |
1480 * @param block the 8x8 block | |
1481 * @param n block index (0-3 are luma, 4-5 are chroma) | |
1482 */ | |
0 | 1483 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
1484 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1485 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
|
1486 RLTable *rl; |
0 | 1487 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1488 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1489 if (s->mb_intra && !s->h263_aic) { |
231 | 1490 /* DC coef */ |
1089 | 1491 level = block[0]; |
0 | 1492 /* 255 cannot be represented, so we clamp */ |
1493 if (level > 254) { | |
1494 level = 254; | |
1495 block[0] = 254; | |
1496 } | |
231 | 1497 /* 0 cannot be represented also */ |
1089 | 1498 else if (level < 1) { |
231 | 1499 level = 1; |
1500 block[0] = 1; | |
1501 } | |
1090 | 1502 if (level == 128) //FIXME check rv10 |
1089 | 1503 put_bits(&s->pb, 8, 0xff); |
1504 else | |
1505 put_bits(&s->pb, 8, level & 0xff); | |
1506 i = 1; | |
0 | 1507 } else { |
1089 | 1508 i = 0; |
1509 if (s->h263_aic && s->mb_intra) | |
1510 rl = &rl_intra_aic; | |
0 | 1511 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1512 |
0 | 1513 /* AC coefs */ |
1514 last_index = s->block_last_index[n]; | |
1515 last_non_zero = i - 1; | |
1516 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1517 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
|
1518 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1519 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1520 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
|
1521 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1522 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1523 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1524 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1525 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1526 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1527 } |
0 | 1528 code = get_rl_index(rl, last, run, level); |
1529 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
1530 if (code == rl->n) { | |
1531 put_bits(&s->pb, 1, last); | |
1532 put_bits(&s->pb, 6, run); | |
1089 | 1533 |
1534 assert(slevel != 0); | |
1535 | |
1536 if(slevel < 128 && slevel > -128) | |
1537 put_bits(&s->pb, 8, slevel & 0xff); | |
1538 else{ | |
1539 put_bits(&s->pb, 8, 128); | |
1540 put_bits(&s->pb, 5, slevel & 0x1f); | |
1541 put_bits(&s->pb, 6, (slevel>>5)&0x3f); | |
1542 } | |
0 | 1543 } else { |
1544 put_bits(&s->pb, 1, sign); | |
1545 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1546 last_non_zero = i; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1547 } |
0 | 1548 } |
1549 } | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1550 #endif |
0 | 1551 |
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
|
1552 #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
|
1553 |
0 | 1554 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1555 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1556 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1557 */ |
453 | 1558 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 1559 { |
1560 int length; | |
1561 put_bits(pbc, 1, 0); | |
1562 length= (-get_bit_count(pbc))&7; | |
453 | 1563 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 1564 } |
1565 | |
327 | 1566 /* must be called before writing the header */ |
1567 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ | |
1568 int time_div, time_mod; | |
1569 | |
1570 if(s->pict_type==I_TYPE){ //we will encode a vol header | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
1571 int dummy; |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
1572 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1); |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
1573 |
327 | 1574 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1; |
1575 } | |
654 | 1576 |
903 | 1577 if(s->current_picture.pts) |
1578 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000); | |
654 | 1579 else |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
1580 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate); |
327 | 1581 time_div= s->time/s->time_increment_resolution; |
1582 time_mod= s->time%s->time_increment_resolution; | |
1583 | |
1584 if(s->pict_type==B_TYPE){ | |
664 | 1585 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
327 | 1586 }else{ |
1587 s->last_time_base= s->time_base; | |
1588 s->time_base= time_div; | |
1589 s->pp_time= s->time - s->last_non_b_time; | |
1590 s->last_non_b_time= s->time; | |
1591 } | |
1592 } | |
1593 | |
942 | 1594 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
1595 int hours, minutes, seconds; | |
1596 | |
1597 put_bits(&s->pb, 16, 0); | |
1598 put_bits(&s->pb, 16, GOP_STARTCODE); | |
1599 | |
1600 seconds= s->time/s->time_increment_resolution; | |
1601 minutes= seconds/60; seconds %= 60; | |
1602 hours= minutes/60; minutes %= 60; | |
1603 hours%=24; | |
1604 | |
1605 put_bits(&s->pb, 5, hours); | |
1606 put_bits(&s->pb, 6, minutes); | |
1607 put_bits(&s->pb, 1, 1); | |
1608 put_bits(&s->pb, 6, seconds); | |
1609 | |
1610 put_bits(&s->pb, 1, 0); //closed gov == NO | |
1611 put_bits(&s->pb, 1, 0); //broken link == NO | |
1612 | |
1613 ff_mpeg4_stuffing(&s->pb); | |
1614 } | |
1615 | |
1616 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
1617 int profile_and_level_indication; | |
1618 int vo_ver_id; | |
1619 | |
1620 if(s->max_b_frames || s->quarter_sample){ | |
1621 profile_and_level_indication= 0xF1; // adv simple level 1 | |
1622 vo_ver_id= 5; | |
1623 }else{ | |
1624 profile_and_level_indication= 0x01; // simple level 1 | |
1625 vo_ver_id= 1; | |
1626 } | |
1627 //FIXME levels | |
1628 | |
1629 put_bits(&s->pb, 16, 0); | |
1630 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1631 |
942 | 1632 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1633 |
942 | 1634 put_bits(&s->pb, 16, 0); |
1635 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
1636 | |
1637 put_bits(&s->pb, 1, 1); | |
1638 put_bits(&s->pb, 4, vo_ver_id); | |
1639 put_bits(&s->pb, 3, 1); //priority | |
1640 | |
1641 put_bits(&s->pb, 4, 1); //visual obj type== video obj | |
1642 | |
1643 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME | |
1644 | |
1645 ff_mpeg4_stuffing(&s->pb); | |
1646 } | |
1647 | |
1648 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 1649 { |
942 | 1650 int vo_ver_id; |
336 | 1651 |
942 | 1652 if(s->max_b_frames || s->quarter_sample){ |
1653 vo_ver_id= 5; | |
923 | 1654 s->vo_type= ADV_SIMPLE_VO_TYPE; |
1655 }else{ | |
942 | 1656 vo_ver_id= 1; |
923 | 1657 s->vo_type= SIMPLE_VO_TYPE; |
1658 } | |
336 | 1659 |
263 | 1660 put_bits(&s->pb, 16, 0); |
942 | 1661 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 1662 put_bits(&s->pb, 16, 0); |
942 | 1663 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 1664 |
1665 put_bits(&s->pb, 1, 0); /* random access vol */ | |
336 | 1666 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ |
263 | 1667 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
1668 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
1669 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | |
880 | 1670 |
887 | 1671 float_aspect_to_info(s, s->avctx->aspect_ratio); |
880 | 1672 |
1673 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1674 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1675 { |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1676 put_bits(&s->pb, 8, s->aspected_width); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1677 put_bits(&s->pb, 8, s->aspected_height); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1678 } |
336 | 1679 |
1680 if(s->low_delay){ | |
1681 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ | |
341 | 1682 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ |
336 | 1683 put_bits(&s->pb, 1, s->low_delay); |
1684 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ | |
1685 }else{ | |
1686 put_bits(&s->pb, 1, 0); /* vol control parameters= no */ | |
1687 } | |
1688 | |
263 | 1689 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ |
1690 put_bits(&s->pb, 1, 1); /* marker bit */ | |
324 | 1691 |
1692 put_bits(&s->pb, 16, s->time_increment_resolution); | |
263 | 1693 if (s->time_increment_bits < 1) |
1694 s->time_increment_bits = 1; | |
1695 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1696 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
1697 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1698 put_bits(&s->pb, 13, s->width); /* vol width */ | |
1699 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1700 put_bits(&s->pb, 13, s->height); /* vol height */ | |
1701 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 1702 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
263 | 1703 put_bits(&s->pb, 1, 1); /* obmc disable */ |
1704 if (vo_ver_id == 1) { | |
1705 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */ | |
942 | 1706 }else{ |
263 | 1707 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */ |
1708 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1709 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1710 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1711 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ |
599 | 1712 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ |
1713 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */ | |
1714 | |
263 | 1715 if (vo_ver_id != 1) |
936 | 1716 put_bits(&s->pb, 1, s->quarter_sample); |
263 | 1717 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 1718 s->resync_marker= s->rtp_mode; |
1719 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
1720 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
1721 if(s->data_partitioning){ | |
1722 put_bits(&s->pb, 1, 0); /* no rvlc */ | |
1723 } | |
1724 | |
263 | 1725 if (vo_ver_id != 1){ |
1726 put_bits(&s->pb, 1, 0); /* newpred */ | |
1727 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
1728 } | |
1729 put_bits(&s->pb, 1, 0); /* scalability */ | |
676 | 1730 |
453 | 1731 ff_mpeg4_stuffing(&s->pb); |
676 | 1732 |
1733 /* user data */ | |
1092 | 1734 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 1735 put_bits(&s->pb, 16, 0); |
1736 put_bits(&s->pb, 16, 0x1B2); /* user_data */ | |
1118 | 1737 put_string(&s->pb, LIBAVCODEC_IDENT); |
676 | 1738 ff_mpeg4_stuffing(&s->pb); |
1739 } | |
263 | 1740 } |
1741 | |
1742 /* write mpeg4 VOP header */ | |
1743 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
1744 { | |
324 | 1745 int time_incr; |
1746 int time_div, time_mod; | |
1747 | |
453 | 1748 if(s->pict_type==I_TYPE){ |
953 | 1749 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1750 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1751 mpeg4_encode_visual_object_header(s); |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1752 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1753 mpeg4_encode_vol_header(s, 0, 0); |
942 | 1754 } |
1755 mpeg4_encode_gop_header(s); | |
453 | 1756 } |
324 | 1757 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1758 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
|
1759 |
324 | 1760 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE); |
1761 | |
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
|
1762 put_bits(&s->pb, 16, 0); /* vop header */ |
942 | 1763 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ |
0 | 1764 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
324 | 1765 |
327 | 1766 time_div= s->time/s->time_increment_resolution; |
1767 time_mod= s->time%s->time_increment_resolution; | |
324 | 1768 time_incr= time_div - s->last_time_base; |
1769 while(time_incr--) | |
1770 put_bits(&s->pb, 1, 1); | |
1771 | |
0 | 1772 put_bits(&s->pb, 1, 0); |
1773 | |
1774 put_bits(&s->pb, 1, 1); /* marker */ | |
324 | 1775 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ |
0 | 1776 put_bits(&s->pb, 1, 1); /* marker */ |
1777 put_bits(&s->pb, 1, 1); /* vop coded */ | |
263 | 1778 if ( s->pict_type == P_TYPE |
1779 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
0 | 1780 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
1781 } | |
1782 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 1783 if(!s->progressive_sequence){ |
1784 put_bits(&s->pb, 1, s->top_field_first); | |
1785 put_bits(&s->pb, 1, s->alternate_scan); | |
1786 } | |
263 | 1787 //FIXME sprite stuff |
0 | 1788 |
1789 put_bits(&s->pb, 5, s->qscale); | |
1790 | |
1791 if (s->pict_type != I_TYPE) | |
1792 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ | |
263 | 1793 if (s->pict_type == B_TYPE) |
1794 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ | |
0 | 1795 // printf("****frame %d\n", picture_number); |
498 | 1796 |
1797 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support | |
1798 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
1799 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
1800 s->v_edge_pos= s->height; |
0 | 1801 } |
1802 | |
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
|
1803 #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
|
1804 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1805 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1806 * change qscale by given dquant and update qscale dependant variables. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1807 */ |
698 | 1808 static void change_qscale(MpegEncContext * s, int dquant) |
0 | 1809 { |
698 | 1810 s->qscale += dquant; |
1811 | |
1812 if (s->qscale < 1) | |
1813 s->qscale = 1; | |
1814 else if (s->qscale > 31) | |
1815 s->qscale = 31; | |
1816 | |
498 | 1817 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
1818 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | |
0 | 1819 } |
1820 | |
1034 | 1821 /** |
1822 * predicts the dc. | |
1823 * @param n block index (0-3 are luma, 4-5 are chroma) | |
1824 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here | |
1825 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
1826 * @return the quantized predicted dc | |
1827 */ | |
1064 | 1828 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr) |
0 | 1829 { |
266 | 1830 int a, b, c, wrap, pred, scale; |
1064 | 1831 uint16_t *dc_val; |
0 | 1832 |
1833 /* find prediction */ | |
1834 if (n < 4) { | |
1835 scale = s->y_dc_scale; | |
1836 } else { | |
1837 scale = s->c_dc_scale; | |
1838 } | |
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
|
1839 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
|
1840 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
|
1841 |
266 | 1842 wrap= s->block_wrap[n]; |
1843 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 1844 |
1845 /* B C | |
1846 * A X | |
1847 */ | |
266 | 1848 a = dc_val[ - 1]; |
1849 b = dc_val[ - 1 - wrap]; | |
1850 c = dc_val[ - wrap]; | |
0 | 1851 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1852 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1853 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1854 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1855 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
|
1856 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1857 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
|
1858 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1859 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1860 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1861 |
0 | 1862 if (abs(a - b) < abs(b - c)) { |
1863 pred = c; | |
1864 *dir_ptr = 1; /* top */ | |
1865 } else { | |
1866 pred = a; | |
1867 *dir_ptr = 0; /* left */ | |
1868 } | |
1869 /* 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
|
1870 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 1871 |
1872 /* prepare address for prediction update */ | |
266 | 1873 *dc_val_ptr = &dc_val[0]; |
0 | 1874 |
1875 return pred; | |
1876 } | |
1877 | |
1034 | 1878 /** |
1879 * predicts the ac. | |
1880 * @param n block index (0-3 are luma, 4-5 are chroma) | |
1881 * @param dir the ac prediction direction | |
1882 */ | |
1008 | 1883 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 1884 int dir) |
1885 { | |
266 | 1886 int i; |
1064 | 1887 int16_t *ac_val, *ac_val1; |
903 | 1888 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 1889 |
1890 /* find prediction */ | |
266 | 1891 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 1892 ac_val1 = ac_val; |
1893 if (s->ac_pred) { | |
1894 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
|
1895 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 1896 /* left prediction */ |
1897 ac_val -= 16; | |
575 | 1898 |
903 | 1899 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 1900 /* same qscale */ |
1901 for(i=1;i<8;i++) { | |
1092 | 1902 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 1903 } |
1904 }else{ | |
1905 /* different qscale, we must rescale */ | |
1906 for(i=1;i<8;i++) { | |
1092 | 1907 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 1908 } |
0 | 1909 } |
1910 } 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
|
1911 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 1912 /* top prediction */ |
266 | 1913 ac_val -= 16 * s->block_wrap[n]; |
575 | 1914 |
903 | 1915 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 1916 /* same qscale */ |
1917 for(i=1;i<8;i++) { | |
1092 | 1918 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 1919 } |
1920 }else{ | |
1921 /* different qscale, we must rescale */ | |
1922 for(i=1;i<8;i++) { | |
1092 | 1923 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 1924 } |
0 | 1925 } |
1926 } | |
1927 } | |
1928 /* left copy */ | |
1929 for(i=1;i<8;i++) | |
1092 | 1930 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 1931 |
0 | 1932 /* top copy */ |
1933 for(i=1;i<8;i++) | |
1092 | 1934 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 1935 |
0 | 1936 } |
1937 | |
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
|
1938 #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
|
1939 |
1008 | 1940 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1941 int dir) |
0 | 1942 { |
266 | 1943 int i; |
1064 | 1944 int16_t *ac_val; |
903 | 1945 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 1946 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1947 /* find prediction */ |
266 | 1948 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
|
1949 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1950 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
|
1951 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1952 /* left prediction */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1953 ac_val -= 16; |
903 | 1954 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
|
1955 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1956 for(i=1;i<8;i++) { |
1092 | 1957 block[s->dsp.idct_permutation[i<<3]] -= ac_val[i]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1958 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1959 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1960 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1961 for(i=1;i<8;i++) { |
1092 | 1962 block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1963 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1964 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1965 } 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
|
1966 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1967 /* top prediction */ |
266 | 1968 ac_val -= 16 * s->block_wrap[n]; |
903 | 1969 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
|
1970 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1971 for(i=1;i<8;i++) { |
1092 | 1972 block[s->dsp.idct_permutation[i]] -= ac_val[i + 8]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1973 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1974 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1975 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1976 for(i=1;i<8;i++) { |
1092 | 1977 block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
1978 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1979 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1980 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1981 } |
0 | 1982 |
1034 | 1983 /** |
1984 * encodes the dc value. | |
1985 * @param n block index (0-3 are luma, 4-5 are chroma) | |
1986 */ | |
453 | 1987 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
|
1988 { |
293 | 1989 #if 1 |
453 | 1990 // if(level<-255 || level>255) printf("dc overflow\n"); |
293 | 1991 level+=256; |
1992 if (n < 4) { | |
1993 /* luminance */ | |
1013 | 1994 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); |
293 | 1995 } else { |
1996 /* chrominance */ | |
1013 | 1997 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); |
293 | 1998 } |
1999 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2000 int size, v; |
0 | 2001 /* find number of bits */ |
2002 size = 0; | |
2003 v = abs(level); | |
2004 while (v) { | |
2005 v >>= 1; | |
2006 size++; | |
2007 } | |
2008 | |
2009 if (n < 4) { | |
2010 /* luminance */ | |
2011 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
2012 } else { | |
2013 /* chrominance */ | |
2014 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
2015 } | |
2016 | |
2017 /* encode remaining bits */ | |
2018 if (size > 0) { | |
2019 if (level < 0) | |
2020 level = (-level) ^ ((1 << size) - 1); | |
2021 put_bits(&s->pb, size, level); | |
2022 if (size > 8) | |
2023 put_bits(&s->pb, 1, 1); | |
2024 } | |
293 | 2025 #endif |
0 | 2026 } |
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
|
2027 |
1034 | 2028 /** |
2029 * encodes a 8x8 block | |
2030 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2031 */ | |
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
|
2032 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2033 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2034 { |
751 | 2035 int i, last_non_zero; |
2036 #if 0 //variables for the outcommented version | |
2037 int code, sign, last; | |
2038 #endif | |
0 | 2039 const RLTable *rl; |
1064 | 2040 uint32_t *bits_tab; |
2041 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
|
2042 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
|
2043 |
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
|
2044 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
0 | 2045 /* mpeg4 based DC predictor */ |
453 | 2046 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
|
2047 if(last_index<1) return; |
0 | 2048 i = 1; |
2049 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
|
2050 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
|
2051 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2052 } 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
|
2053 if(last_index<0) return; |
0 | 2054 i = 0; |
2055 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
|
2056 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
|
2057 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2058 } |
2059 | |
2060 /* AC coefs */ | |
2061 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
|
2062 #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
|
2063 for (; i < last_index; i++) { |
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
|
2064 int level = block[ scan_table[i] ]; |
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
|
2065 if (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
|
2066 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
|
2067 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
|
2068 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
|
2069 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
|
2070 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
|
2071 }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
|
2072 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
|
2073 } |
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
|
2074 last_non_zero = i; |
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
|
2075 } |
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
|
2076 } |
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
|
2077 /*if(i<=last_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
|
2078 int level = block[ scan_table[i] ]; |
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
|
2079 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
|
2080 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
|
2081 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
|
2082 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
|
2083 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
|
2084 }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
|
2085 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
|
2086 } |
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
|
2087 } |
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
|
2088 #else |
0 | 2089 for (; i <= last_index; 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
|
2090 const int slevel = block[ scan_table[i] ]; |
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
|
2091 if (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
|
2092 int 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
|
2093 int run = i - last_non_zero - 1; |
0 | 2094 last = (i == last_index); |
2095 sign = 0; | |
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
|
2096 level = slevel; |
0 | 2097 if (level < 0) { |
2098 sign = 1; | |
2099 level = -level; | |
2100 } | |
2101 code = get_rl_index(rl, last, run, level); | |
453 | 2102 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2103 if (code == rl->n) { |
2104 int level1, run1; | |
2105 level1 = level - rl->max_level[last][run]; | |
2106 if (level1 < 1) | |
2107 goto esc2; | |
2108 code = get_rl_index(rl, last, run, level1); | |
2109 if (code == rl->n) { | |
2110 esc2: | |
453 | 2111 put_bits(ac_pb, 1, 1); |
0 | 2112 if (level > MAX_LEVEL) |
2113 goto esc3; | |
2114 run1 = run - rl->max_run[last][level] - 1; | |
2115 if (run1 < 0) | |
2116 goto esc3; | |
2117 code = get_rl_index(rl, last, run1, level); | |
2118 if (code == rl->n) { | |
2119 esc3: | |
2120 /* third escape */ | |
453 | 2121 put_bits(ac_pb, 1, 1); |
2122 put_bits(ac_pb, 1, last); | |
2123 put_bits(ac_pb, 6, run); | |
2124 put_bits(ac_pb, 1, 1); | |
2125 put_bits(ac_pb, 12, slevel & 0xfff); | |
2126 put_bits(ac_pb, 1, 1); | |
0 | 2127 } else { |
2128 /* second escape */ | |
453 | 2129 put_bits(ac_pb, 1, 0); |
2130 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2131 put_bits(ac_pb, 1, sign); | |
0 | 2132 } |
2133 } else { | |
2134 /* first escape */ | |
453 | 2135 put_bits(ac_pb, 1, 0); |
2136 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2137 put_bits(ac_pb, 1, sign); | |
0 | 2138 } |
2139 } else { | |
453 | 2140 put_bits(ac_pb, 1, sign); |
0 | 2141 } |
2142 last_non_zero = i; | |
2143 } | |
2144 } | |
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
|
2145 #endif |
0 | 2146 } |
936 | 2147 |
2148 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, | |
1064 | 2149 uint8_t *scan_table) |
936 | 2150 { |
2151 int i, last_non_zero; | |
2152 const RLTable *rl; | |
1064 | 2153 uint8_t *len_tab; |
936 | 2154 const int last_index = s->block_last_index[n]; |
2155 int len=0; | |
2156 | |
2157 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2158 /* mpeg4 based DC predictor */ | |
2159 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME | |
2160 if(last_index<1) return len; | |
2161 i = 1; | |
2162 rl = &rl_intra; | |
2163 len_tab = uni_mpeg4_intra_rl_len; | |
2164 } else { | |
2165 if(last_index<0) return 0; | |
2166 i = 0; | |
2167 rl = &rl_inter; | |
2168 len_tab = uni_mpeg4_inter_rl_len; | |
2169 } | |
2170 | |
2171 /* AC coefs */ | |
2172 last_non_zero = i - 1; | |
2173 for (; i < last_index; i++) { | |
2174 int level = block[ scan_table[i] ]; | |
2175 if (level) { | |
2176 int run = i - last_non_zero - 1; | |
2177 level+=64; | |
2178 if((level&(~127)) == 0){ | |
2179 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2180 len += len_tab[index]; | |
2181 }else{ //ESC3 | |
2182 len += 7+2+1+6+1+12+1; | |
2183 } | |
2184 last_non_zero = i; | |
2185 } | |
2186 } | |
2187 /*if(i<=last_index)*/{ | |
2188 int level = block[ scan_table[i] ]; | |
2189 int run = i - last_non_zero - 1; | |
2190 level+=64; | |
2191 if((level&(~127)) == 0){ | |
2192 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2193 len += len_tab[index]; | |
2194 }else{ //ESC3 | |
2195 len += 7+2+1+6+1+12+1; | |
2196 } | |
2197 } | |
2198 | |
2199 return len; | |
2200 } | |
2201 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2202 #endif |
0 | 2203 |
2204 | |
2205 /***********************************************/ | |
2206 /* decoding */ | |
2207 | |
2208 static VLC intra_MCBPC_vlc; | |
2209 static VLC inter_MCBPC_vlc; | |
2210 static VLC cbpy_vlc; | |
2211 static VLC mv_vlc; | |
2212 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2213 static VLC sprite_trajectory; |
262 | 2214 static VLC mb_type_b_vlc; |
0 | 2215 |
2216 void init_vlc_rl(RLTable *rl) | |
2217 { | |
542 | 2218 int i, q; |
2219 | |
0 | 2220 init_vlc(&rl->vlc, 9, rl->n + 1, |
2221 &rl->table_vlc[0][1], 4, 2, | |
2222 &rl->table_vlc[0][0], 4, 2); | |
542 | 2223 |
2224 | |
2225 for(q=0; q<32; q++){ | |
2226 int qmul= q*2; | |
2227 int qadd= (q-1)|1; | |
2228 | |
2229 if(q==0){ | |
2230 qmul=1; | |
2231 qadd=0; | |
2232 } | |
2233 | |
2234 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); | |
2235 for(i=0; i<rl->vlc.table_size; i++){ | |
2236 int code= rl->vlc.table[i][0]; | |
2237 int len = rl->vlc.table[i][1]; | |
2238 int level, run; | |
2239 | |
2240 if(len==0){ // illegal code | |
563 | 2241 run= 66; |
542 | 2242 level= MAX_LEVEL; |
2243 }else if(len<0){ //more bits needed | |
2244 run= 0; | |
2245 level= code; | |
2246 }else{ | |
2247 if(code==rl->n){ //esc | |
563 | 2248 run= 66; |
542 | 2249 level= 0; |
2250 }else{ | |
2251 run= rl->table_run [code] + 1; | |
2252 level= rl->table_level[code] * qmul + qadd; | |
2253 if(code >= rl->last) run+=192; | |
2254 } | |
2255 } | |
2256 rl->rl_vlc[q][i].len= len; | |
2257 rl->rl_vlc[q][i].level= level; | |
2258 rl->rl_vlc[q][i].run= run; | |
2259 } | |
2260 } | |
0 | 2261 } |
2262 | |
2263 /* init vlcs */ | |
2264 | |
2265 /* XXX: find a better solution to handle static init */ | |
2266 void h263_decode_init_vlc(MpegEncContext *s) | |
2267 { | |
2268 static int done = 0; | |
2269 | |
2270 if (!done) { | |
2271 done = 1; | |
2272 | |
544 | 2273 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8, |
0 | 2274 intra_MCBPC_bits, 1, 1, |
2275 intra_MCBPC_code, 1, 1); | |
544 | 2276 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25, |
0 | 2277 inter_MCBPC_bits, 1, 1, |
2278 inter_MCBPC_code, 1, 1); | |
544 | 2279 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16, |
0 | 2280 &cbpy_tab[0][1], 2, 1, |
2281 &cbpy_tab[0][0], 2, 1); | |
544 | 2282 init_vlc(&mv_vlc, MV_VLC_BITS, 33, |
0 | 2283 &mvtab[0][1], 2, 1, |
2284 &mvtab[0][0], 2, 1); | |
2285 init_rl(&rl_inter); | |
2286 init_rl(&rl_intra); | |
1132 | 2287 init_rl(&rvlc_rl_inter); |
2288 init_rl(&rvlc_rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
2289 init_rl(&rl_intra_aic); |
0 | 2290 init_vlc_rl(&rl_inter); |
2291 init_vlc_rl(&rl_intra); | |
1132 | 2292 init_vlc_rl(&rvlc_rl_inter); |
2293 init_vlc_rl(&rvlc_rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
2294 init_vlc_rl(&rl_intra_aic); |
549 | 2295 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2296 &DCtab_lum[0][1], 2, 1, |
2297 &DCtab_lum[0][0], 2, 1); | |
549 | 2298 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, |
0 | 2299 &DCtab_chrom[0][1], 2, 1, |
2300 &DCtab_chrom[0][0], 2, 1); | |
544 | 2301 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
|
2302 &sprite_trajectory_tab[0][1], 4, 2, |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2303 &sprite_trajectory_tab[0][0], 4, 2); |
544 | 2304 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, |
262 | 2305 &mb_type_b_tab[0][1], 2, 1, |
2306 &mb_type_b_tab[0][0], 2, 1); | |
0 | 2307 } |
2308 } | |
2309 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2310 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2311 * 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
|
2312 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2313 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
|
2314 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2315 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2316 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2317 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2318 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2319 return 4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2320 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2321 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2322 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2323 * decodes the group of blocks header. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2324 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2325 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2326 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 2327 { |
2328 unsigned int val, gfid; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2329 int left; |
162 | 2330 |
2331 /* Check for GOB Start Code */ | |
2332 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2333 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2334 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2335 |
162 | 2336 /* 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
|
2337 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
|
2338 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
|
2339 //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
|
2340 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2341 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
|
2342 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2343 if(left<=13) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2344 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2345 |
162 | 2346 #ifdef DEBUG |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2347 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x); |
162 | 2348 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2349 s->gob_number = get_bits(&s->gb, 5); /* GN */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2350 gfid = get_bits(&s->gb, 2); /* GFID */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2351 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2352 if(s->qscale==0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2353 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2354 s->mb_x= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2355 s->mb_y= s->gob_index* s->gob_number; |
162 | 2356 #ifdef DEBUG |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2357 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale); |
162 | 2358 #endif |
2359 return 0; | |
2360 } | |
2361 | |
290 | 2362 static inline void memsetw(short *tab, int val, int n) |
2363 { | |
2364 int i; | |
2365 for(i=0;i<n;i++) | |
2366 tab[i] = val; | |
2367 } | |
2368 | |
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
|
2369 #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
|
2370 |
453 | 2371 void ff_mpeg4_init_partitions(MpegEncContext *s) |
2372 { | |
2373 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL); | |
2374 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL); | |
2375 } | |
2376 | |
2377 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 2378 { |
453 | 2379 const int pb2_len = get_bit_count(&s->pb2 ); |
2380 const int tex_pb_len= get_bit_count(&s->tex_pb); | |
2381 const int bits= get_bit_count(&s->pb); | |
2382 | |
2383 if(s->pict_type==I_TYPE){ | |
2384 put_bits(&s->pb, 19, DC_MARKER); | |
2385 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
2386 s->i_tex_bits+= tex_pb_len; | |
2387 }else{ | |
2388 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
|
2389 s->misc_bits+=17 + pb2_len; |
453 | 2390 s->mv_bits+= bits - s->last_bits; |
2391 s->p_tex_bits+= tex_pb_len; | |
2392 } | |
2393 | |
2394 flush_put_bits(&s->pb2); | |
2395 flush_put_bits(&s->tex_pb); | |
2396 | |
2397 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len); | |
2398 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len); | |
2399 s->last_bits= get_bit_count(&s->pb); | |
2400 } | |
2401 | |
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
|
2402 #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
|
2403 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2404 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
|
2405 switch(s->pict_type){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2406 case I_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2407 return 16; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2408 case P_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2409 case S_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2410 return s->f_code+15; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2411 case B_TYPE: |
847 | 2412 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
|
2413 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2414 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2415 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2416 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2417 |
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
|
2418 #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
|
2419 |
453 | 2420 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
2421 { | |
2422 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
2423 | |
2424 ff_mpeg4_stuffing(&s->pb); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2425 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 2426 put_bits(&s->pb, 1, 1); |
2427 | |
2428 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
|
2429 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 2430 put_bits(&s->pb, 1, 0); /* no HEC */ |
2431 } | |
2432 | |
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
|
2433 #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
|
2434 |
453 | 2435 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2436 * 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
|
2437 * @return 0 if not |
453 | 2438 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2439 static inline int mpeg4_is_resync(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2440 const int bits_count= get_bits_count(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2441 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2442 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
|
2443 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2444 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2445 |
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
|
2446 if(bits_count + 8 >= s->gb.size_in_bits){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2447 int v= show_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2448 v|= 0x7F >> (7-(bits_count&7)); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2449 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2450 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2451 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2452 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2453 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2454 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2455 GetBitContext gb= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2456 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2457 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2458 align_get_bits(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2459 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2460 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2461 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2462 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2463 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2464 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2465 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2466 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
|
2467 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2468 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2469 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2470 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2471 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2472 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2473 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2474 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2475 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2476 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2477 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 2478 { |
290 | 2479 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
|
2480 int header_extension=0, mb_num, len; |
453 | 2481 |
2482 /* 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
|
2483 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
|
2484 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2485 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2486 if(get_bits1(&s->gb)) break; |
453 | 2487 } |
2488 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2489 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
|
2490 printf("marker does not match f_code\n"); |
453 | 2491 return -1; |
2492 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2493 |
453 | 2494 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2495 header_extension= get_bits1(&s->gb); |
453 | 2496 //FIXME more stuff here |
2497 } | |
2498 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2499 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
|
2500 if(mb_num>=s->mb_num){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2501 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 2502 return -1; |
2503 } | |
1176 | 2504 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
|
2505 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
1176 | 2506 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded |
2507 } | |
2508 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2509 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
|
2510 s->mb_y= mb_num / s->mb_width; |
453 | 2511 |
2512 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2513 int qscale= get_bits(&s->gb, s->quant_precision); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2514 if(qscale) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2515 s->qscale= qscale; |
290 | 2516 } |
2517 | |
2518 if(s->shape == RECT_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2519 header_extension= get_bits1(&s->gb); |
290 | 2520 } |
2521 if(header_extension){ | |
453 | 2522 int time_increment; |
290 | 2523 int time_incr=0; |
453 | 2524 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2525 while (get_bits1(&s->gb) != 0) |
290 | 2526 time_incr++; |
2527 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2528 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
|
2529 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
|
2530 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
290 | 2531 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2532 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 2533 //FIXME not rect stuff here |
2534 | |
2535 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2536 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2537 //FIXME dont just ignore everything |
821 | 2538 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
290 | 2539 mpeg4_decode_sprite_trajectory(s); |
660 | 2540 fprintf(stderr, "untested\n"); |
290 | 2541 } |
2542 | |
2543 //FIXME reduced res stuff here | |
2544 | |
2545 if (s->pict_type != I_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2546 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 2547 if(f_code==0){ |
2548 printf("Error, video packet header damaged (f_code=0)\n"); | |
290 | 2549 } |
2550 } | |
2551 if (s->pict_type == B_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2552 int b_code = get_bits(&s->gb, 3); |
660 | 2553 if(b_code==0){ |
2554 printf("Error, video packet header damaged (b_code=0)\n"); | |
2555 } | |
290 | 2556 } |
2557 } | |
2558 } | |
2559 //FIXME new-pred stuff | |
453 | 2560 |
2561 //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)); | |
2562 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2563 return 0; |
453 | 2564 } |
2565 | |
2566 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
2567 { | |
2568 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 2569 |
2570 l_wrap= s->block_wrap[0]; | |
453 | 2571 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2; |
290 | 2572 c_wrap= s->block_wrap[4]; |
453 | 2573 c_xy= s->mb_y*c_wrap + s->mb_x; |
290 | 2574 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2575 #if 0 |
290 | 2576 /* clean DC */ |
453 | 2577 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
2578 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
2579 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
|
2580 #endif |
290 | 2581 |
2582 /* clean AC */ | |
1064 | 2583 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
2584 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
2585 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 2586 |
2587 /* clean MV */ | |
453 | 2588 // we cant clear the MVs as they might be needed by a b frame |
1064 | 2589 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
2590 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 2591 s->last_mv[0][0][0]= |
2592 s->last_mv[0][0][1]= | |
2593 s->last_mv[1][0][0]= | |
2594 s->last_mv[1][0][1]= 0; | |
2595 } | |
2596 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2597 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2598 * 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
|
2599 * @return <0 if no resync found |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2600 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2601 int ff_h263_resync(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2602 int left, ret; |
453 | 2603 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2604 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2605 skip_bits1(&s->gb); |
453 | 2606 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2607 align_get_bits(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2608 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2609 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2610 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2611 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2612 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2613 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2614 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2615 return 0; |
453 | 2616 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2617 //ok, its not where its supposed to be ... |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2618 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2619 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
|
2620 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
453 | 2621 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2622 for(;left>16+1+5+5; left-=8){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2623 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2624 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2625 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2626 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2627 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2628 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2629 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2630 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2631 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2632 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2633 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2634 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2635 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2636 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2637 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2638 return -1; |
453 | 2639 } |
2640 | |
2641 /** | |
1034 | 2642 * gets the average motion vector for a GMC MB. |
753 | 2643 * @param n either 0 for the x component or 1 for y |
2644 * @returns the average MV for a GMC MB | |
2645 */ | |
2646 static inline int get_amv(MpegEncContext *s, int n){ | |
2647 int x, y, mb_v, sum, dx, dy, shift; | |
2648 int len = 1 << (s->f_code + 4); | |
2649 const int a= s->sprite_warping_accuracy; | |
2650 | |
2651 if(s->real_sprite_warping_points==1){ | |
2652 if(s->divx_version==500 && s->divx_build==413) | |
2653 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
2654 else | |
2655 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
2656 }else{ | |
2657 dx= s->sprite_delta[n][0]; | |
2658 dy= s->sprite_delta[n][1]; | |
2659 shift= s->sprite_shift[0]; | |
2660 if(n) dy -= 1<<(shift + a + 1); | |
2661 else dx -= 1<<(shift + a + 1); | |
2662 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
2663 | |
2664 sum=0; | |
2665 for(y=0; y<16; y++){ | |
2666 int v; | |
2667 | |
2668 v= mb_v + dy*y; | |
2669 //XXX FIXME optimize | |
2670 for(x=0; x<16; x++){ | |
2671 sum+= v>>shift; | |
2672 v+= dx; | |
2673 } | |
2674 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
2675 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 2676 } |
2677 | |
2678 if (sum < -len) sum= -len; | |
2679 else if (sum >= len) sum= len-1; | |
2680 | |
2681 return sum; | |
2682 } | |
2683 | |
2684 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2685 * decodes first partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2686 * @return number of MBs decoded or <0 if an error occured |
453 | 2687 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2688 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
|
2689 int mb_num; |
1064 | 2690 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
453 | 2691 |
2692 /* decode first partition */ | |
2693 mb_num=0; | |
290 | 2694 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2695 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
|
2696 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2697 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
|
2698 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 2699 int cbpc; |
2700 int dir=0; | |
2701 | |
2702 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2703 ff_update_block_index(s); |
453 | 2704 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
2705 s->first_slice_line=0; | |
2706 | |
2707 if(s->pict_type==I_TYPE){ | |
2708 int i; | |
2709 | |
1257 | 2710 if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2711 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2712 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2713 |
544 | 2714 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1); |
453 | 2715 if (cbpc < 0){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2716 |
453 | 2717 fprintf(stderr, "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
|
2718 return -1; |
453 | 2719 } |
2720 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
|
2721 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 2722 s->mb_intra = 1; |
2723 | |
2724 if(cbpc & 4) { | |
698 | 2725 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 2726 } |
903 | 2727 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 2728 |
2729 s->mbintra_table[xy]= 1; | |
2730 for(i=0; i<6; i++){ | |
2731 int dc_pred_dir; | |
2732 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
2733 if(dc < 0){ | |
2734 fprintf(stderr, "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
|
2735 return -1; |
453 | 2736 } |
2737 dir<<=1; | |
2738 if(dc_pred_dir) dir|=1; | |
2739 } | |
2740 s->pred_dir_table[xy]= dir; | |
2741 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2742 int mx, my, pred_x, pred_y, bits; |
1064 | 2743 int16_t * const mot_val= s->motion_val[s->block_index[0]]; |
453 | 2744 const int stride= s->block_wrap[0]*2; |
2745 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2746 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2747 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2748 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2749 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2750 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2751 if(bits&0x10000){ |
453 | 2752 /* skip mb */ |
2753 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
|
2754 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 2755 mx= get_amv(s, 0); |
2756 my= get_amv(s, 1); | |
453 | 2757 }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
|
2758 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 2759 mx=my=0; |
453 | 2760 } |
2761 mot_val[0 ]= mot_val[2 ]= | |
2762 mot_val[0+stride]= mot_val[2+stride]= mx; | |
2763 mot_val[1 ]= mot_val[3 ]= | |
2764 mot_val[1+stride]= mot_val[3+stride]= my; | |
2765 | |
2766 if(s->mbintra_table[xy]) | |
2767 ff_clean_intra_table_entries(s); | |
2768 continue; | |
2769 } | |
544 | 2770 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 2771 if (cbpc < 0){ |
2772 fprintf(stderr, "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
|
2773 return -1; |
453 | 2774 } |
2775 if (cbpc > 20) | |
2776 cbpc+=3; | |
2777 else if (cbpc == 20) | |
2778 fprintf(stderr, "Stuffing !"); | |
2779 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant | |
2780 | |
2781 s->mb_intra = ((cbpc & 4) != 0); | |
2782 | |
2783 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
|
2784 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 2785 s->mbintra_table[xy]= 1; |
2786 mot_val[0 ]= mot_val[2 ]= | |
2787 mot_val[0+stride]= mot_val[2+stride]= 0; | |
2788 mot_val[1 ]= mot_val[3 ]= | |
2789 mot_val[1+stride]= mot_val[3+stride]= 0; | |
2790 }else{ | |
2791 if(s->mbintra_table[xy]) | |
2792 ff_clean_intra_table_entries(s); | |
2793 | |
2794 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | |
2795 s->mcsel= get_bits1(&s->gb); | |
2796 else s->mcsel= 0; | |
2797 | |
2798 if ((cbpc & 16) == 0) { | |
2799 /* 16x16 motion prediction */ | |
2800 | |
2801 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
753 | 2802 if(!s->mcsel){ |
2803 mx = h263_decode_motion(s, pred_x, s->f_code); | |
2804 if (mx >= 0xffff) | |
2805 return -1; | |
2806 | |
2807 my = h263_decode_motion(s, pred_y, s->f_code); | |
2808 if (my >= 0xffff) | |
2809 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
|
2810 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 2811 } else { |
2812 mx = get_amv(s, 0); | |
2813 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
|
2814 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 2815 } |
753 | 2816 |
453 | 2817 mot_val[0 ]= mot_val[2 ] = |
2818 mot_val[0+stride]= mot_val[2+stride]= mx; | |
2819 mot_val[1 ]= mot_val[3 ]= | |
2820 mot_val[1+stride]= mot_val[3+stride]= my; | |
2821 } else { | |
2822 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
|
2823 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 2824 for(i=0;i<4;i++) { |
1064 | 2825 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); |
453 | 2826 mx = h263_decode_motion(s, pred_x, s->f_code); |
2827 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2828 return -1; |
453 | 2829 |
2830 my = h263_decode_motion(s, pred_y, s->f_code); | |
2831 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2832 return -1; |
453 | 2833 mot_val[0] = mx; |
2834 mot_val[1] = my; | |
2835 } | |
2836 } | |
2837 } | |
2838 } | |
2839 } | |
2840 s->mb_x= 0; | |
2841 } | |
2842 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2843 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2844 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2845 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2846 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2847 * decode second partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2848 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2849 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2850 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
|
2851 int mb_num=0; |
1064 | 2852 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
|
2853 |
453 | 2854 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
|
2855 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2856 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
|
2857 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2858 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
|
2859 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 2860 |
2861 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2862 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2863 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
|
2864 s->first_slice_line=0; |
453 | 2865 |
2866 if(s->pict_type==I_TYPE){ | |
2867 int ac_pred= get_bits1(&s->gb); | |
544 | 2868 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 2869 if(cbpy<0){ |
2870 fprintf(stderr, "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
|
2871 return -1; |
453 | 2872 } |
2873 | |
2874 s->cbp_table[xy]|= cbpy<<2; | |
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
|
2875 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 2876 }else{ /* P || S_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
|
2877 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 2878 int dir=0,i; |
2879 int ac_pred = get_bits1(&s->gb); | |
544 | 2880 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 2881 |
2882 if(cbpy<0){ | |
2883 fprintf(stderr, "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
|
2884 return -1; |
453 | 2885 } |
2886 | |
2887 if(s->cbp_table[xy] & 8) { | |
698 | 2888 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 2889 } |
903 | 2890 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 2891 |
2892 for(i=0; i<6; i++){ | |
2893 int dc_pred_dir; | |
2894 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
2895 if(dc < 0){ | |
2896 fprintf(stderr, "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
|
2897 return -1; |
453 | 2898 } |
2899 dir<<=1; | |
2900 if(dc_pred_dir) dir|=1; | |
2901 } | |
2902 s->cbp_table[xy]&= 3; //remove dquant | |
2903 s->cbp_table[xy]|= cbpy<<2; | |
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
|
2904 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
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
|
2905 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
|
2906 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 2907 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 2908 s->cbp_table[xy]= 0; |
2909 }else{ | |
544 | 2910 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 2911 |
2912 if(cbpy<0){ | |
2913 fprintf(stderr, "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
|
2914 return -1; |
453 | 2915 } |
2916 | |
2917 if(s->cbp_table[xy] & 8) { | |
698 | 2918 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 2919 } |
903 | 2920 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 2921 |
2922 s->cbp_table[xy]&= 3; //remove dquant | |
2923 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
2924 } | |
2925 } | |
2926 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2927 if(mb_num >= mb_count) return 0; |
453 | 2928 s->mb_x= 0; |
2929 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2930 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2931 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2932 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2933 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2934 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2935 * @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
|
2936 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2937 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2938 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2939 int mb_num; |
1144 | 2940 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
2941 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END; | |
453 | 2942 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2943 mb_num= mpeg4_decode_partition_a(s); |
1144 | 2944 if(mb_num<0){ |
2945 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
|
2946 return -1; |
1144 | 2947 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2948 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2949 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2950 fprintf(stderr, "slice below monitor ...\n"); |
1144 | 2951 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
|
2952 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2953 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2954 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2955 s->mb_num_left= mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2956 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2957 if(s->pict_type==I_TYPE){ |
1257 | 2958 if(get_bits_long(&s->gb, 19)!=DC_MARKER){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2959 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2960 return -1; |
1144 | 2961 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2962 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2963 if(get_bits(&s->gb, 17)!=MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2964 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2965 return -1; |
1144 | 2966 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2967 } |
1144 | 2968 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2969 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2970 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
1144 | 2971 if(s->pict_type==P_TYPE) |
2972 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
|
2973 return -1; |
1144 | 2974 }else{ |
2975 if(s->pict_type==P_TYPE) | |
2976 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
|
2977 } |
453 | 2978 |
2979 return 0; | |
2980 } | |
2981 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2982 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2983 * decode partition C of one MB. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2984 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2985 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2986 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 2987 { |
2988 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
|
2989 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
|
2990 |
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
|
2991 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
|
2992 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2993 |
903 | 2994 if(s->current_picture.qscale_table[xy] != s->qscale){ |
2995 s->qscale= s->current_picture.qscale_table[xy]; | |
698 | 2996 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
2997 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | |
453 | 2998 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2999 |
453 | 3000 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
3001 int i; | |
3002 for(i=0; i<4; i++){ | |
3003 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0]; | |
3004 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1]; | |
3005 } | |
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
|
3006 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
|
3007 |
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
|
3008 if (IS_SKIP(mb_type)) { |
453 | 3009 /* skip mb */ |
3010 for(i=0;i<6;i++) | |
3011 s->block_last_index[i] = -1; | |
3012 s->mv_dir = MV_DIR_FORWARD; | |
3013 s->mv_type = MV_TYPE_16X16; | |
3014 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
3015 s->mcsel=1; | |
3016 s->mb_skiped = 0; | |
3017 }else{ | |
3018 s->mcsel=0; | |
3019 s->mb_skiped = 1; | |
3020 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3021 }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
|
3022 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3023 }else if(!s->mb_intra){ |
3024 // s->mcsel= 0; //FIXME do we need to init that | |
3025 | |
3026 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
|
3027 if (IS_8X8(mb_type)) { |
453 | 3028 s->mv_type = MV_TYPE_8X8; |
3029 } else { | |
3030 s->mv_type = MV_TYPE_16X16; | |
3031 } | |
3032 } | |
3033 } else { /* I-Frame */ | |
3034 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
|
3035 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3036 } |
3037 | |
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
|
3038 if (!IS_SKIP(mb_type)) { |
1132 | 3039 int i; |
453 | 3040 /* decode each block */ |
3041 for (i = 0; i < 6; i++) { | |
1132 | 3042 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ |
3043 fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); | |
453 | 3044 return -1; |
3045 } | |
718 | 3046 cbp+=cbp; |
453 | 3047 } |
3048 } | |
290 | 3049 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3050 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3051 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3052 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
|
3053 //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
|
3054 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3055 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3056 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3057 return SLICE_NOEND; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3058 }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
|
3059 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
|
3060 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
|
3061 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
|
3062 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
|
3063 } |
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
|
3064 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3065 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3066 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3067 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3068 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3069 DCTELEM block[6][64]) |
0 | 3070 { |
3071 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3072 int16_t *mot_val; |
3073 static int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
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
|
3074 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
359 | 3075 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3076 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
21 | 3077 if (get_bits1(&s->gb)) { |
0 | 3078 /* skip mb */ |
3079 s->mb_intra = 0; | |
3080 for(i=0;i<6;i++) | |
3081 s->block_last_index[i] = -1; | |
3082 s->mv_dir = MV_DIR_FORWARD; | |
3083 s->mv_type = MV_TYPE_16X16; | |
255 | 3084 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
|
3085 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3086 s->mcsel=1; |
753 | 3087 s->mv[0][0][0]= get_amv(s, 0); |
3088 s->mv[0][0][1]= get_amv(s, 1); | |
255 | 3089 |
3090 s->mb_skiped = 0; | |
3091 }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
|
3092 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3093 s->mcsel=0; |
3094 s->mv[0][0][0] = 0; | |
3095 s->mv[0][0][1] = 0; | |
3096 s->mb_skiped = 1; | |
3097 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3098 goto end; |
0 | 3099 } |
544 | 3100 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
144 | 3101 //fprintf(stderr, "\tCBPC: %d", cbpc); |
0 | 3102 if (cbpc < 0) |
3103 return -1; | |
161 | 3104 if (cbpc > 20) |
3105 cbpc+=3; | |
3106 else if (cbpc == 20) | |
3107 fprintf(stderr, "Stuffing !"); | |
144 | 3108 |
0 | 3109 dquant = cbpc & 8; |
3110 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3111 if (s->mb_intra) goto intra; |
3112 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3113 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3114 s->mcsel= get_bits1(&s->gb); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3115 else s->mcsel= 0; |
544 | 3116 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
0 | 3117 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2); |
3118 if (dquant) { | |
698 | 3119 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
0 | 3120 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3121 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
|
3122 s->interlaced_dct= get_bits1(&s->gb); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3123 |
0 | 3124 s->mv_dir = MV_DIR_FORWARD; |
3125 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3126 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
|
3127 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
|
3128 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3129 s->mv_type = MV_TYPE_16X16; |
753 | 3130 mx= get_amv(s, 0); |
3131 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
|
3132 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
|
3133 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
|
3134 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
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
|
3135 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
|
3136 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3137 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
|
3138 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3139 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
|
3140 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
|
3141 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3142 h263_pred_motion(s, 0, &pred_x, &pred_y); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3143 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3144 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
|
3145 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
|
3146 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3147 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3148 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3149 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
|
3150 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3151 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3152 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3153 s->mv[0][i][0] = mx; |
661 | 3154 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
|
3155 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3156 }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
|
3157 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
|
3158 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3159 s->mv_type = MV_TYPE_16X16; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3160 h263_pred_motion(s, 0, &pred_x, &pred_y); |
1089 | 3161 if (s->umvplus) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3162 mx = h263p_decode_umotion(s, pred_x); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3163 else |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3164 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
|
3165 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3166 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3167 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3168 |
1089 | 3169 if (s->umvplus) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3170 my = h263p_decode_umotion(s, pred_y); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3171 else |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3172 my = h263_decode_motion(s, pred_y, s->f_code); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3173 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3174 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3175 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3176 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
|
3177 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
|
3178 |
1089 | 3179 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3180 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
255 | 3181 } |
0 | 3182 } 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
|
3183 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 3184 s->mv_type = MV_TYPE_8X8; |
3185 for(i=0;i<4;i++) { | |
3186 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); | |
1089 | 3187 if (s->umvplus) |
78 | 3188 mx = h263p_decode_umotion(s, pred_x); |
3189 else | |
262 | 3190 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 3191 if (mx >= 0xffff) |
3192 return -1; | |
78 | 3193 |
1089 | 3194 if (s->umvplus) |
78 | 3195 my = h263p_decode_umotion(s, pred_y); |
3196 else | |
262 | 3197 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 3198 if (my >= 0xffff) |
3199 return -1; | |
3200 s->mv[0][i][0] = mx; | |
3201 s->mv[0][i][1] = my; | |
1089 | 3202 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
78 | 3203 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
0 | 3204 mot_val[0] = mx; |
3205 mot_val[1] = my; | |
3206 } | |
3207 } | |
262 | 3208 } else if(s->pict_type==B_TYPE) { |
3209 int modb1; // first bit of modb | |
3210 int modb2; // second bit of modb | |
3211 int mb_type; | |
3212 | |
3213 s->mb_intra = 0; //B-frames never contain intra blocks | |
3214 s->mcsel=0; // ... true gmc blocks | |
3215 | |
3216 if(s->mb_x==0){ | |
674 | 3217 for(i=0; i<2; i++){ |
3218 s->last_mv[i][0][0]= | |
3219 s->last_mv[i][0][1]= | |
3220 s->last_mv[i][1][0]= | |
3221 s->last_mv[i][1][1]= 0; | |
3222 } | |
262 | 3223 } |
3224 | |
3225 /* if we skipped it in the future P Frame than skip it now too */ | |
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
|
3226 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC |
262 | 3227 |
3228 if(s->mb_skiped){ | |
3229 /* skip mb */ | |
3230 for(i=0;i<6;i++) | |
3231 s->block_last_index[i] = -1; | |
3232 | |
3233 s->mv_dir = MV_DIR_FORWARD; | |
3234 s->mv_type = MV_TYPE_16X16; | |
3235 s->mv[0][0][0] = 0; | |
3236 s->mv[0][0][1] = 0; | |
3237 s->mv[1][0][0] = 0; | |
3238 s->mv[1][0][1] = 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
|
3239 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
|
3240 goto end; |
262 | 3241 } |
3242 | |
666 | 3243 modb1= get_bits1(&s->gb); |
3244 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
|
3245 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 3246 cbp=0; |
3247 }else{ | |
262 | 3248 modb2= get_bits1(&s->gb); |
544 | 3249 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
|
3250 if(mb_type<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
|
3251 printf("illegal MB_type\n"); |
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
|
3252 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
|
3253 } |
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
|
3254 mb_type= mb_type_b_map[ mb_type ]; |
666 | 3255 if(modb2) cbp= 0; |
3256 else cbp= get_bits(&s->gb, 6); | |
3257 | |
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
|
3258 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 3259 if(get_bits1(&s->gb)){ |
698 | 3260 change_qscale(s, get_bits1(&s->gb)*4 - 2); |
262 | 3261 } |
3262 } | |
664 | 3263 |
3264 if(!s->progressive_sequence){ | |
3265 if(cbp) | |
3266 s->interlaced_dct= get_bits1(&s->gb); | |
3267 | |
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
|
3268 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
|
3269 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
|
3270 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
|
3271 |
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
|
3272 if(USES_LIST(mb_type, 0)){ |
667 | 3273 s->field_select[0][0]= get_bits1(&s->gb); |
3274 s->field_select[0][1]= get_bits1(&s->gb); | |
3275 } | |
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
|
3276 if(USES_LIST(mb_type, 1)){ |
667 | 3277 s->field_select[1][0]= get_bits1(&s->gb); |
3278 s->field_select[1][1]= get_bits1(&s->gb); | |
3279 } | |
3280 } | |
666 | 3281 } |
3282 | |
667 | 3283 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
|
3284 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 3285 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
|
3286 |
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
|
3287 if(USES_LIST(mb_type, 0)){ |
666 | 3288 s->mv_dir = MV_DIR_FORWARD; |
3289 | |
3290 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
3291 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
3292 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
3293 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 3294 } |
666 | 3295 |
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
|
3296 if(USES_LIST(mb_type, 1)){ |
666 | 3297 s->mv_dir |= MV_DIR_BACKWARD; |
3298 | |
3299 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
3300 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
3301 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
3302 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
3303 } | |
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
|
3304 }else if(!IS_DIRECT(mb_type)){ |
666 | 3305 s->mv_type= MV_TYPE_FIELD; |
667 | 3306 |
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
|
3307 if(USES_LIST(mb_type, 0)){ |
666 | 3308 s->mv_dir = MV_DIR_FORWARD; |
3309 | |
3310 for(i=0; i<2; i++){ | |
3311 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
3312 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
3313 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
3314 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
3315 } | |
667 | 3316 } |
666 | 3317 |
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
|
3318 if(USES_LIST(mb_type, 1)){ |
666 | 3319 s->mv_dir |= MV_DIR_BACKWARD; |
3320 | |
3321 for(i=0; i<2; i++){ | |
3322 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
3323 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
3324 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
3325 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 3326 } |
3327 } | |
3328 } | |
3329 } | |
666 | 3330 |
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
|
3331 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
|
3332 if(IS_SKIP(mb_type)) |
666 | 3333 mx=my=0; |
3334 else{ | |
3335 mx = h263_decode_motion(s, 0, 1); | |
3336 my = h263_decode_motion(s, 0, 1); | |
3337 } | |
664 | 3338 |
262 | 3339 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
|
3340 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 3341 } |
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
|
3342 s->current_picture.mb_type[xy]= mb_type; |
262 | 3343 } else { /* I-Frame */ |
544 | 3344 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1); |
262 | 3345 if (cbpc < 0) |
3346 return -1; | |
3347 dquant = cbpc & 4; | |
3348 s->mb_intra = 1; | |
3349 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
|
3350 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3351 if (s->h263_pred || s->h263_aic) { |
21 | 3352 s->ac_pred = get_bits1(&s->gb); |
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
|
3353 if(s->ac_pred){ |
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
|
3354 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
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
|
3355 |
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
|
3356 if (s->h263_aic) |
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
|
3357 s->h263_aic_dir = 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
|
3358 } |
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
|
3359 }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
|
3360 s->ac_pred = 0; |
591 | 3361 |
544 | 3362 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3363 if(cbpy<0) return -1; |
0 | 3364 cbp = (cbpc & 3) | (cbpy << 2); |
3365 if (dquant) { | |
698 | 3366 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
0 | 3367 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3368 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3369 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3370 s->interlaced_dct= get_bits1(&s->gb); |
575 | 3371 |
3372 /* decode each block */ | |
3373 if (s->h263_pred) { | |
3374 for (i = 0; i < 6; i++) { | |
1132 | 3375 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) |
575 | 3376 return -1; |
718 | 3377 cbp+=cbp; |
575 | 3378 } |
3379 } else { | |
3380 for (i = 0; i < 6; i++) { | |
718 | 3381 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
575 | 3382 return -1; |
718 | 3383 cbp+=cbp; |
575 | 3384 } |
3385 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3386 goto end; |
0 | 3387 } |
3388 | |
3389 /* decode each block */ | |
3390 if (s->h263_pred) { | |
575 | 3391 for (i = 0; i < 6; i++) { |
1132 | 3392 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) |
0 | 3393 return -1; |
718 | 3394 cbp+=cbp; |
575 | 3395 } |
0 | 3396 } else { |
575 | 3397 for (i = 0; i < 6; i++) { |
718 | 3398 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
0 | 3399 return -1; |
718 | 3400 cbp+=cbp; |
575 | 3401 } |
0 | 3402 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3403 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3404 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3405 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3406 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3407 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
|
3408 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
|
3409 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
|
3410 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3411 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3412 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3413 }else{ |
892
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3414 int v= show_bits(&s->gb, 16); |
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3415 |
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
|
3416 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ |
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
|
3417 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3418 } |
892
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3419 |
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3420 if(v==0) |
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3421 return SLICE_END; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3422 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3423 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3424 return SLICE_OK; |
0 | 3425 } |
3426 | |
262 | 3427 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 3428 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
3429 int code, val, sign, shift, l; |
544 | 3430 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 3431 |
3432 if (code == 0) | |
3433 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
|
3434 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
|
3435 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3436 |
21 | 3437 sign = get_bits1(&s->gb); |
262 | 3438 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
|
3439 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3440 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3441 val = (val - 1) << shift; |
0 | 3442 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
|
3443 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3444 } |
0 | 3445 if (sign) |
3446 val = -val; | |
3447 val += pred; | |
475 | 3448 |
0 | 3449 /* modulo decoding */ |
3450 if (!s->h263_long_vectors) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3451 l = 1 << (f_code + 4); |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3452 val = ((val + l)&(l*2-1)) - l; |
0 | 3453 } else { |
3454 /* horrible h263 long vector mode */ | |
3455 if (pred < -31 && val < -63) | |
3456 val += 64; | |
3457 if (pred > 32 && val > 63) | |
3458 val -= 64; | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
3459 |
0 | 3460 } |
3461 return val; | |
3462 } | |
3463 | |
78 | 3464 /* Decodes RVLC of H.263+ UMV */ |
3465 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
3466 { | |
3467 int code = 0, sign; | |
3468 | |
3469 if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
3470 return pred; | |
3471 | |
3472 code = 2 + get_bits1(&s->gb); | |
3473 | |
3474 while (get_bits1(&s->gb)) | |
3475 { | |
3476 code <<= 1; | |
3477 code += get_bits1(&s->gb); | |
3478 } | |
3479 sign = code & 1; | |
3480 code >>= 1; | |
3481 | |
3482 code = (sign) ? (pred - code) : (pred + code); | |
3483 #ifdef DEBUG | |
3484 fprintf(stderr,"H.263+ UMV Motion = %d\n", code); | |
3485 #endif | |
3486 return code; | |
3487 | |
3488 } | |
3489 | |
0 | 3490 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
3491 int n, int coded) | |
3492 { | |
3493 int code, level, i, j, last, run; | |
3494 RLTable *rl = &rl_inter; | |
1064 | 3495 const uint8_t *scan_table; |
0 | 3496 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3497 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3498 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3499 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3500 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3501 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3502 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3503 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3504 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3505 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3506 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3507 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3508 /* DC coef */ |
1090 | 3509 if(s->h263_rv10){ |
3510 if (s->rv10_version == 3 && s->pict_type == I_TYPE) { | |
0 | 3511 int component, diff; |
3512 component = (n <= 3 ? 0 : n - 4 + 1); | |
3513 level = s->last_dc[component]; | |
3514 if (s->rv10_first_dc_coded[component]) { | |
3515 diff = rv_decode_dc(s, n); | |
3516 if (diff == 0xffff) | |
3517 return -1; | |
3518 level += diff; | |
3519 level = level & 0xff; /* handle wrap round */ | |
3520 s->last_dc[component] = level; | |
3521 } else { | |
3522 s->rv10_first_dc_coded[component] = 1; | |
3523 } | |
1090 | 3524 } else { |
3525 level = get_bits(&s->gb, 8); | |
3526 } | |
3527 }else{ | |
0 | 3528 level = get_bits(&s->gb, 8); |
1089 | 3529 if((level&0x7F) == 0){ |
1090 | 3530 fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
1089 | 3531 return -1; |
3532 } | |
0 | 3533 if (level == 255) |
3534 level = 128; | |
3535 } | |
3536 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3537 i = 1; |
0 | 3538 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3539 i = 0; |
0 | 3540 } |
3541 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3542 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3543 goto not_coded; |
0 | 3544 s->block_last_index[n] = i - 1; |
3545 return 0; | |
3546 } | |
3547 | |
3548 for(;;) { | |
544 | 3549 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
|
3550 if (code < 0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3551 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 3552 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3553 } |
0 | 3554 if (code == rl->n) { |
3555 /* escape */ | |
21 | 3556 last = get_bits1(&s->gb); |
0 | 3557 run = get_bits(&s->gb, 6); |
1064 | 3558 level = (int8_t)get_bits(&s->gb, 8); |
1089 | 3559 if(level == -128){ |
3560 if (s->h263_rv10) { | |
3561 /* XXX: should patch encoder too */ | |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
3562 level = get_sbits(&s->gb, 12); |
1089 | 3563 }else{ |
3564 level = get_bits(&s->gb, 5); | |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
3565 level |= get_sbits(&s->gb, 6)<<5; |
1089 | 3566 } |
0 | 3567 } |
3568 } else { | |
3569 run = rl->table_run[code]; | |
3570 level = rl->table_level[code]; | |
3571 last = code >= rl->last; | |
21 | 3572 if (get_bits1(&s->gb)) |
0 | 3573 level = -level; |
3574 } | |
3575 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3576 if (i >= 64){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3577 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y); |
0 | 3578 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3579 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3580 j = scan_table[i]; |
0 | 3581 block[j] = level; |
3582 if (last) | |
3583 break; | |
3584 i++; | |
3585 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3586 not_coded: |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3587 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3588 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
3589 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3590 } |
0 | 3591 s->block_last_index[n] = i; |
3592 return 0; | |
3593 } | |
3594 | |
1034 | 3595 /** |
3596 * decodes the dc value. | |
3597 * @param n block index (0-3 are luma, 4-5 are chroma) | |
3598 * @param dir_ptr the prediction direction will be stored here | |
3599 * @return the quantized dc | |
3600 */ | |
453 | 3601 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 3602 { |
3603 int level, pred, code; | |
1064 | 3604 uint16_t *dc_val; |
0 | 3605 |
3606 if (n < 4) | |
544 | 3607 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
0 | 3608 else |
544 | 3609 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 3610 if (code < 0 || code > 9 /* && s->nbit<9 */){ |
3611 fprintf(stderr, "illegal dc vlc\n"); | |
0 | 3612 return -1; |
453 | 3613 } |
0 | 3614 if (code == 0) { |
3615 level = 0; | |
3616 } 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
|
3617 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
|
3618 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
|
3619 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
|
3620 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
|
3621 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
|
3622 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
|
3623 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
|
3624 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
|
3625 } |
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
|
3626 }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
|
3627 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
|
3628 } |
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
|
3629 |
453 | 3630 if (code > 8){ |
3631 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
|
3632 if(s->error_resilience>=2){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3633 fprintf(stderr, "dc marker bit missing\n"); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3634 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3635 } |
453 | 3636 } |
3637 } | |
0 | 3638 } |
498 | 3639 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
0 | 3640 level += pred; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3641 if (level < 0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3642 if(s->error_resilience>=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3643 fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3644 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3645 } |
0 | 3646 level = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3647 } |
0 | 3648 if (n < 4) { |
3649 *dc_val = level * s->y_dc_scale; | |
3650 } else { | |
3651 *dc_val = level * s->c_dc_scale; | |
3652 } | |
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
|
3653 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
|
3654 *dc_val = level * 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
|
3655 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3656 if(s->error_resilience>=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3657 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3658 fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3659 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3660 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3661 } |
0 | 3662 return level; |
3663 } | |
3664 | |
453 | 3665 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3666 * decodes a block. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3667 * @return <0 if an error occured |
453 | 3668 */ |
3669 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 3670 int n, int coded, int intra, int rvlc) |
0 | 3671 { |
549 | 3672 int level, i, last, run; |
0 | 3673 int dc_pred_dir; |
575 | 3674 RLTable * rl; |
3675 RL_VLC_ELEM * rl_vlc; | |
1064 | 3676 const uint8_t * scan_table; |
549 | 3677 int qmul, qadd; |
0 | 3678 |
1132 | 3679 //Note intra & rvlc should be optimized away if this is inlined |
3680 | |
575 | 3681 if(intra) { |
0 | 3682 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3683 if(s->partitioned_frame){ |
453 | 3684 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
|
3685 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
|
3686 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
|
3687 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 3688 }else{ |
3689 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
3690 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3691 return -1; |
453 | 3692 } |
0 | 3693 block[0] = level; |
549 | 3694 i = 0; |
0 | 3695 if (!coded) |
3696 goto not_coded; | |
1132 | 3697 |
3698 if(rvlc){ | |
3699 rl = &rvlc_rl_intra; | |
3700 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
3701 }else{ | |
3702 rl = &rl_intra; | |
3703 rl_vlc = rl_intra.rl_vlc[0]; | |
3704 } | |
718 | 3705 if (s->ac_pred) { |
0 | 3706 if (dc_pred_dir == 0) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3707 scan_table = s->intra_v_scantable.permutated; /* left */ |
0 | 3708 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3709 scan_table = s->intra_h_scantable.permutated; /* top */ |
0 | 3710 } else { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3711 scan_table = s->intra_scantable.permutated; |
0 | 3712 } |
549 | 3713 qmul=1; |
3714 qadd=0; | |
0 | 3715 } else { |
549 | 3716 i = -1; |
0 | 3717 if (!coded) { |
549 | 3718 s->block_last_index[n] = i; |
0 | 3719 return 0; |
3720 } | |
1132 | 3721 if(rvlc) rl = &rvlc_rl_inter; |
3722 else rl = &rl_inter; | |
661 | 3723 |
718 | 3724 scan_table = s->intra_scantable.permutated; |
661 | 3725 |
591 | 3726 if(s->mpeg_quant){ |
3727 qmul=1; | |
3728 qadd=0; | |
1132 | 3729 if(rvlc){ |
3730 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
3731 }else{ | |
3732 rl_vlc = rl_inter.rl_vlc[0]; | |
3733 } | |
591 | 3734 }else{ |
3735 qmul = s->qscale << 1; | |
3736 qadd = (s->qscale - 1) | 1; | |
1132 | 3737 if(rvlc){ |
3738 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
3739 }else{ | |
3740 rl_vlc = rl_inter.rl_vlc[s->qscale]; | |
3741 } | |
591 | 3742 } |
0 | 3743 } |
549 | 3744 { |
3745 OPEN_READER(re, &s->gb); | |
0 | 3746 for(;;) { |
549 | 3747 UPDATE_CACHE(re, &s->gb); |
3748 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
3749 if (level==0) { | |
1132 | 3750 /* escape */ |
3751 if(rvlc){ | |
3752 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
3753 fprintf(stderr, "1. marker bit missing in rvlc esc\n"); | |
3754 return -1; | |
3755 }; SKIP_CACHE(re, &s->gb, 1); | |
3756 | |
3757 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
3758 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
3759 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
3760 UPDATE_CACHE(re, &s->gb); | |
3761 | |
3762 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
3763 fprintf(stderr, "2. marker bit missing in rvlc esc\n"); | |
3764 return -1; | |
3765 }; SKIP_CACHE(re, &s->gb, 1); | |
3766 | |
3767 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); | |
3768 | |
3769 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ | |
3770 fprintf(stderr, "reverse esc missing\n"); | |
3771 return -1; | |
3772 }; SKIP_CACHE(re, &s->gb, 5); | |
3773 | |
3774 level= level * qmul + qadd; | |
3775 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
3776 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
3777 | |
3778 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
|
3779 if(last) i+=192; |
1132 | 3780 }else{ |
549 | 3781 int cache; |
3782 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
|
3783 |
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
|
3784 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
|
3785 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
|
3786 |
549 | 3787 if (cache&0x80000000) { |
3788 if (cache&0x40000000) { | |
0 | 3789 /* third escape */ |
549 | 3790 SKIP_CACHE(re, &s->gb, 2); |
3791 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
3792 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
3793 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
3794 UPDATE_CACHE(re, &s->gb); | |
3795 | |
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
|
3796 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
|
3797 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
|
3798 }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
|
3799 if(SHOW_UBITS(re, &s->gb, 1)==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
|
3800 fprintf(stderr, "1. marker bit missing in 3. esc\n"); |
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
|
3801 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
|
3802 }; 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
|
3803 |
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
|
3804 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
|
3805 |
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
|
3806 if(SHOW_UBITS(re, &s->gb, 1)==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
|
3807 fprintf(stderr, "2. marker bit missing in 3. esc\n"); |
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
|
3808 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
|
3809 }; 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
|
3810 |
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
|
3811 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
|
3812 } |
549 | 3813 |
597 | 3814 if(level*s->qscale>1024 || level*s->qscale<-1024){ |
3815 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3816 return -1; |
453 | 3817 } |
3818 #if 1 | |
3819 { | |
3820 const int abs_level= ABS(level); | |
921 | 3821 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){ |
498 | 3822 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 3823 if(abs_level <= rl->max_level[last][run]){ |
3824 fprintf(stderr, "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
|
3825 return -1; |
453 | 3826 } |
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
|
3827 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
|
3828 if(abs_level <= rl->max_level[last][run]*2){ |
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
|
3829 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n"); |
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
|
3830 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
|
3831 } |
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
|
3832 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ |
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
|
3833 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n"); |
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
|
3834 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
|
3835 } |
453 | 3836 } |
3837 } | |
3838 } | |
3839 #endif | |
549 | 3840 if (level>0) level= level * qmul + qadd; |
3841 else level= level * qmul - qadd; | |
3842 | |
3843 i+= run + 1; | |
3844 if(last) i+=192; | |
0 | 3845 } else { |
3846 /* second escape */ | |
549 | 3847 #if MIN_CACHE_BITS < 20 |
3848 LAST_SKIP_BITS(re, &s->gb, 2); | |
3849 UPDATE_CACHE(re, &s->gb); | |
3850 #else | |
3851 SKIP_BITS(re, &s->gb, 2); | |
3852 #endif | |
3853 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
3854 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing | |
3855 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
3856 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 3857 } |
3858 } else { | |
3859 /* first escape */ | |
549 | 3860 #if MIN_CACHE_BITS < 19 |
3861 LAST_SKIP_BITS(re, &s->gb, 1); | |
3862 UPDATE_CACHE(re, &s->gb); | |
3863 #else | |
3864 SKIP_BITS(re, &s->gb, 1); | |
3865 #endif | |
3866 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
3867 i+= run; | |
3868 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
3869 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
3870 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 3871 } |
1132 | 3872 } |
0 | 3873 } else { |
549 | 3874 i+= run; |
3875 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
3876 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 3877 } |
549 | 3878 if (i > 62){ |
3879 i-= 192; | |
3880 if(i&(~63)){ | |
3881 fprintf(stderr, "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
|
3882 return -1; |
549 | 3883 } |
3884 | |
3885 block[scan_table[i]] = level; | |
0 | 3886 break; |
549 | 3887 } |
3888 | |
3889 block[scan_table[i]] = level; | |
0 | 3890 } |
549 | 3891 CLOSE_READER(re, &s->gb); |
3892 } | |
0 | 3893 not_coded: |
3894 if (s->mb_intra) { | |
3895 mpeg4_pred_ac(s, block, n, dc_pred_dir); | |
3896 if (s->ac_pred) { | |
549 | 3897 i = 63; /* XXX: not optimal */ |
0 | 3898 } |
3899 } | |
549 | 3900 s->block_last_index[n] = i; |
0 | 3901 return 0; |
3902 } | |
3903 | |
3904 /* most is hardcoded. should extend to handle all h263 streams */ | |
3905 int h263_decode_picture_header(MpegEncContext *s) | |
3906 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3907 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3908 uint32_t startcode; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3909 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3910 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3911 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3912 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3913 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3914 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>0; i--) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3915 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3916 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3917 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3918 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3919 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3920 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
3921 if (startcode != 0x20) { |
355 | 3922 fprintf(stderr, "Bad picture start code\n"); |
0 | 3923 return -1; |
355 | 3924 } |
3925 /* temporal reference */ | |
231 | 3926 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
355 | 3927 |
3928 /* PTYPE starts here */ | |
3929 if (get_bits1(&s->gb) != 1) { | |
3930 /* marker */ | |
3931 fprintf(stderr, "Bad marker\n"); | |
3932 return -1; | |
3933 } | |
3934 if (get_bits1(&s->gb) != 0) { | |
3935 fprintf(stderr, "Bad H263 id\n"); | |
0 | 3936 return -1; /* h263 id */ |
355 | 3937 } |
21 | 3938 skip_bits1(&s->gb); /* split screen off */ |
3939 skip_bits1(&s->gb); /* camera off */ | |
3940 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 3941 |
155
3c3449bce692
- Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents:
154
diff
changeset
|
3942 /* Reset GOB number */ |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
3943 s->gob_number = 0; |
155
3c3449bce692
- Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents:
154
diff
changeset
|
3944 |
0 | 3945 format = get_bits(&s->gb, 3); |
355 | 3946 /* |
3947 0 forbidden | |
3948 1 sub-QCIF | |
3949 10 QCIF | |
3950 7 extended PTYPE (PLUSPTYPE) | |
3951 */ | |
0 | 3952 |
161 | 3953 if (format != 7 && format != 6) { |
0 | 3954 s->h263_plus = 0; |
3955 /* H.263v1 */ | |
3956 width = h263_format[format][0]; | |
3957 height = h263_format[format][1]; | |
3958 if (!width) | |
3959 return -1; | |
161 | 3960 |
3961 s->width = width; | |
3962 s->height = height; | |
21 | 3963 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 3964 |
21 | 3965 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 3966 s->h263_long_vectors = s->unrestricted_mv; |
3967 | |
355 | 3968 if (get_bits1(&s->gb) != 0) { |
3969 fprintf(stderr, "H263 SAC not supported\n"); | |
0 | 3970 return -1; /* SAC: off */ |
355 | 3971 } |
161 | 3972 if (get_bits1(&s->gb) != 0) { |
3973 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
3974 } | |
3975 | |
355 | 3976 if (get_bits1(&s->gb) != 0) { |
3977 fprintf(stderr, "H263 PB frame not supported\n"); | |
0 | 3978 return -1; /* not PB frame */ |
355 | 3979 } |
0 | 3980 s->qscale = get_bits(&s->gb, 5); |
21 | 3981 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 3982 } else { |
161 | 3983 int ufep; |
3984 | |
0 | 3985 /* H.263v2 */ |
161 | 3986 s->h263_plus = 1; |
3987 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 3988 |
3989 /* ufep other than 0 and 1 are reserved */ | |
161 | 3990 if (ufep == 1) { |
3991 /* OPPTYPE */ | |
3992 format = get_bits(&s->gb, 3); | |
355 | 3993 dprintf("ufep=1, format: %d\n", format); |
161 | 3994 skip_bits(&s->gb,1); /* Custom PCF */ |
1089 | 3995 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */ |
161 | 3996 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */ |
3997 if (get_bits1(&s->gb) != 0) { | |
3998 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
3999 } | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4000 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4001 s->h263_aic = 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4002 } |
355 | 4003 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4004 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4005 fprintf(stderr, "Deblocking Filter not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4006 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4007 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4008 fprintf(stderr, "Slice Structured not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4009 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4010 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4011 fprintf(stderr, "Reference Picture Selection not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4012 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4013 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4014 fprintf(stderr, "Independent Segment Decoding not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4015 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4016 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4017 fprintf(stderr, "Alternative Inter VLC not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4018 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4019 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4020 fprintf(stderr, "Modified Quantization not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4021 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4022 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4023 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 4024 |
161 | 4025 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 4026 } else if (ufep != 0) { |
4027 fprintf(stderr, "Bad UFEP type (%d)\n", ufep); | |
0 | 4028 return -1; |
355 | 4029 } |
161 | 4030 |
78 | 4031 /* MPPTYPE */ |
355 | 4032 s->pict_type = get_bits(&s->gb, 3) + I_TYPE; |
4033 dprintf("pict_type: %d\n", s->pict_type); | |
0 | 4034 if (s->pict_type != I_TYPE && |
4035 s->pict_type != P_TYPE) | |
4036 return -1; | |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4037 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4038 s->no_rounding = get_bits1(&s->gb); |
355 | 4039 dprintf("RTYPE: %d\n", s->no_rounding); |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4040 skip_bits(&s->gb, 4); |
78 | 4041 |
4042 /* Get the picture dimensions */ | |
161 | 4043 if (ufep) { |
4044 if (format == 6) { | |
4045 /* Custom Picture Format (CPFMT) */ | |
355 | 4046 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4047 dprintf("aspect: %d\n", s->aspect_ratio_info); | |
4048 /* aspect ratios: | |
4049 0 - forbidden | |
4050 1 - 1:1 | |
4051 2 - 12:11 (CIF 4:3) | |
4052 3 - 10:11 (525-type 4:3) | |
4053 4 - 16:11 (CIF 16:9) | |
4054 5 - 40:33 (525-type 16:9) | |
4055 6-14 - reserved | |
4056 */ | |
161 | 4057 width = (get_bits(&s->gb, 9) + 1) * 4; |
4058 skip_bits1(&s->gb); | |
4059 height = get_bits(&s->gb, 9) * 4; | |
355 | 4060 dprintf("\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
|
4061 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 4062 /* aspected dimensions */ |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
4063 s->aspected_width = get_bits(&s->gb, 8); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
4064 s->aspected_height = get_bits(&s->gb, 8); |
887 | 4065 }else{ |
4066 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0]; | |
4067 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1]; | |
355 | 4068 } |
4069 } else { | |
161 | 4070 width = h263_format[format][0]; |
4071 height = h263_format[format][1]; | |
4072 } | |
4073 if ((width == 0) || (height == 0)) | |
4074 return -1; | |
4075 s->width = width; | |
4076 s->height = height; | |
1089 | 4077 if (s->umvplus) { |
4078 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
4079 skip_bits1(&s->gb); | |
161 | 4080 } |
78 | 4081 } |
4082 | |
0 | 4083 s->qscale = get_bits(&s->gb, 5); |
4084 } | |
4085 /* PEI */ | |
21 | 4086 while (get_bits1(&s->gb) != 0) { |
4087 skip_bits(&s->gb, 8); | |
0 | 4088 } |
4089 s->f_code = 1; | |
498 | 4090 |
4091 if(s->h263_aic){ | |
4092 s->y_dc_scale_table= | |
4093 s->c_dc_scale_table= h263_aic_dc_scale_table; | |
4094 }else{ | |
4095 s->y_dc_scale_table= | |
4096 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
4097 } | |
4098 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4099 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4100 printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4101 s->qscale, av_get_pict_type_char(s->pict_type), |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4102 s->gb.size_in_bits, 1-s->no_rounding, |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4103 s->mv_type == MV_TYPE_8X8 ? "ADV" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4104 s->umvplus ? "UMV" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4105 s->h263_long_vectors ? "LONG" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4106 s->h263_plus ? "+" : "" |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4107 ); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4108 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4109 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4110 |
0 | 4111 return 0; |
4112 } | |
4113 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4114 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4115 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4116 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4117 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4118 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4119 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4120 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
|
4121 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
|
4122 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4123 int virtual_ref[2][2]; |
753 | 4124 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4125 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4126 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4127 int h= s->height; |
753 | 4128 int min_ab; |
4129 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4130 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
|
4131 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4132 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4133 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4134 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4135 if(length){ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
4136 x= get_xbits(&s->gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4137 } |
255 | 4138 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */ |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4139 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4140 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4141 if(length){ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
4142 y=get_xbits(&s->gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4143 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4144 skip_bits1(&s->gb); /* marker bit */ |
255 | 4145 //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
|
4146 d[i][0]= x; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4147 d[i][1]= y; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4148 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4149 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4150 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4151 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
|
4152 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4153 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4154 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4155 // Note, the 4th point isnt used for GMC |
262 | 4156 if(s->divx_version==500 && s->divx_build==413){ |
4157 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
4158 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
4159 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
4160 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
4161 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
4162 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
4163 } else { | |
4164 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
4165 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
4166 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
4167 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
4168 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
4169 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
4170 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4171 /* 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
|
4172 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4173 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4174 // 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
|
4175 // 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
|
4176 // 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
|
4177 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4178 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 4179 + 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); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4180 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 4181 + 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); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4182 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 4183 + 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); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4184 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 4185 + 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); |
753 | 4186 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4187 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4188 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4189 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4190 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4191 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4192 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4193 s->sprite_offset[1][1]= 0; |
753 | 4194 s->sprite_delta[0][0]= a; |
4195 s->sprite_delta[0][1]= 0; | |
4196 s->sprite_delta[1][0]= 0; | |
4197 s->sprite_delta[1][1]= a; | |
4198 s->sprite_shift[0]= 0; | |
4199 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4200 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4201 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4202 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
|
4203 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
|
4204 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
|
4205 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 4206 s->sprite_delta[0][0]= a; |
4207 s->sprite_delta[0][1]= 0; | |
4208 s->sprite_delta[1][0]= 0; | |
4209 s->sprite_delta[1][1]= a; | |
4210 s->sprite_shift[0]= 0; | |
4211 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4212 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4213 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4214 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 4215 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
4216 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
4217 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4218 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 4219 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
4220 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
4221 + (1<<(alpha+rho-1)); | |
4222 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
4223 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
4224 +2*w2*r*sprite_ref[0][0] | |
4225 - 16*w2 | |
4226 + (1<<(alpha+rho+1))); | |
4227 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) | |
4228 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) | |
4229 +2*w2*r*sprite_ref[0][1] | |
4230 - 16*w2 | |
4231 + (1<<(alpha+rho+1))); | |
4232 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
4233 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
4234 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
4235 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
4236 | |
4237 s->sprite_shift[0]= alpha+rho; | |
4238 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
|
4239 break; |
753 | 4240 case 3: |
847 | 4241 min_ab= FFMIN(alpha, beta); |
753 | 4242 w3= w2>>min_ab; |
4243 h3= h2>>min_ab; | |
4244 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
4245 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
4246 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
4247 + (1<<(alpha+beta+rho-min_ab-1)); | |
4248 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
4249 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
4250 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
4251 + (1<<(alpha+beta+rho-min_ab-1)); | |
4252 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
4253 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
4254 + 2*w2*h3*r*sprite_ref[0][0] | |
4255 - 16*w2*h3 | |
4256 + (1<<(alpha+beta+rho-min_ab+1)); | |
4257 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
4258 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
4259 + 2*w2*h3*r*sprite_ref[0][1] | |
4260 - 16*w2*h3 | |
4261 + (1<<(alpha+beta+rho-min_ab+1)); | |
4262 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
4263 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
4264 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
4265 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
4266 | |
4267 s->sprite_shift[0]= alpha + beta + rho - min_ab; | |
4268 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
|
4269 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4270 } |
255 | 4271 /* try to simplify the situation */ |
753 | 4272 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
4273 && s->sprite_delta[0][1] == 0 | |
4274 && s->sprite_delta[1][0] == 0 | |
4275 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 4276 { |
753 | 4277 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
4278 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
4279 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
4280 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
4281 s->sprite_delta[0][0]= a; | |
4282 s->sprite_delta[0][1]= 0; | |
4283 s->sprite_delta[1][0]= 0; | |
4284 s->sprite_delta[1][1]= a; | |
4285 s->sprite_shift[0]= 0; | |
4286 s->sprite_shift[1]= 0; | |
255 | 4287 s->real_sprite_warping_points=1; |
4288 } | |
753 | 4289 else{ |
4290 int shift_y= 16 - s->sprite_shift[0]; | |
4291 int shift_c= 16 - s->sprite_shift[1]; | |
4292 //printf("shifts %d %d\n", shift_y, shift_c); | |
4293 for(i=0; i<2; i++){ | |
4294 s->sprite_offset[0][i]<<= shift_y; | |
4295 s->sprite_offset[1][i]<<= shift_c; | |
4296 s->sprite_delta[0][i]<<= shift_y; | |
4297 s->sprite_delta[1][i]<<= shift_y; | |
4298 s->sprite_shift[i]= 16; | |
4299 } | |
255 | 4300 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 4301 } |
4302 #if 0 | |
4303 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", | |
4304 vop_ref[0][0], vop_ref[0][1], | |
4305 vop_ref[1][0], vop_ref[1][1], | |
4306 vop_ref[2][0], vop_ref[2][1], | |
4307 sprite_ref[0][0], sprite_ref[0][1], | |
4308 sprite_ref[1][0], sprite_ref[1][1], | |
4309 sprite_ref[2][0], sprite_ref[2][1], | |
4310 virtual_ref[0][0], virtual_ref[0][1], | |
4311 virtual_ref[1][0], virtual_ref[1][1] | |
4312 ); | |
4313 | |
4314 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", | |
4315 s->sprite_offset[0][0], s->sprite_offset[0][1], | |
4316 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
4317 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
4318 s->sprite_shift[0] | |
4319 ); | |
4320 #endif | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4321 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4322 |
942 | 4323 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
4324 int hours, minutes, seconds; | |
4325 | |
4326 hours= get_bits(gb, 5); | |
4327 minutes= get_bits(gb, 6); | |
4328 skip_bits1(gb); | |
4329 seconds= get_bits(gb, 6); | |
4330 | |
4331 s->time_base= seconds + 60*(minutes + 60*hours); | |
4332 | |
4333 skip_bits1(gb); | |
4334 skip_bits1(gb); | |
4335 | |
4336 return 0; | |
4337 } | |
4338 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4339 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
|
4340 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
|
4341 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4342 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4343 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
|
4344 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
|
4345 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
|
4346 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
|
4347 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
|
4348 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4349 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4350 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4351 //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
|
4352 s->aspect_ratio_info= get_bits(gb, 4); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4353 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4354 s->aspected_width = get_bits(gb, 8); // par_width |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4355 s->aspected_height = get_bits(gb, 8); // par_height |
887 | 4356 }else{ |
4357 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0]; | |
4358 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1]; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4359 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4360 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4361 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
|
4362 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
|
4363 if(chroma_format!=1){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4364 printf("illegal chroma format\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4365 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4366 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
|
4367 if(get_bits1(gb)){ /* vbv parameters */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4368 get_bits(gb, 15); /* first_half_bitrate */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4369 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4370 get_bits(gb, 15); /* latter_half_bitrate */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4371 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4372 get_bits(gb, 15); /* first_half_vbv_buffer_size */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4373 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4374 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4375 get_bits(gb, 11); /* first_half_vbv_occupancy */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4376 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4377 get_bits(gb, 15); /* latter_half_vbv_occupancy */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4378 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4379 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4380 }else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4381 // set low delay flag only once so the smart? low delay detection wont be overriden |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4382 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4383 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4384 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4385 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4386 s->shape = get_bits(gb, 2); /* vol shape */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4387 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4388 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4389 printf("Gray shape not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4390 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
|
4391 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4392 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4393 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4394 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4395 s->time_increment_resolution = get_bits(gb, 16); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4396 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4397 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4398 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
|
4399 s->time_increment_bits = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4400 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4401 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4402 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4403 skip_bits(gb, s->time_increment_bits); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4404 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4405 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4406 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
|
4407 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4408 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4409 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4410 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4411 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4412 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4413 if(width && height){ /* they should be non zero but who knows ... */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4414 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4415 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4416 // 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
|
4417 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4418 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4419 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4420 s->progressive_sequence= get_bits1(gb)^1; |
1237 | 4421 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
4422 printf("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
|
4423 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4424 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
|
4425 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4426 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
|
4427 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4428 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4429 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
|
4430 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
|
4431 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
|
4432 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4433 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
|
4434 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4435 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
|
4436 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4437 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
|
4438 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4439 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4440 s->num_sprite_warping_points= get_bits(gb, 6); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4441 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
|
4442 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
|
4443 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
|
4444 s->low_latency_sprite= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4445 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4446 // FIXME sadct disable bit if verid!=1 && shape not rect |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4447 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4448 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
|
4449 s->quant_precision = get_bits(gb, 4); /* quant_precision */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4450 if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4451 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4452 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4453 s->quant_precision = 5; |
0 | 4454 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4455 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4456 // 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
|
4457 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4458 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 4459 int i, v; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4460 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4461 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4462 for(i=0; i<64; i++){ |
1092 | 4463 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
|
4464 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
|
4465 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4466 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
|
4467 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4468 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
|
4469 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4470 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
|
4471 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4472 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4473 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4474 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4475 int last=0; |
1057 | 4476 for(i=0; i<64; i++){ |
4477 int j; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4478 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4479 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4480 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4481 last= v; |
1092 | 4482 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
|
4483 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4484 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
|
4485 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4486 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4487 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4488 for(; i<64; i++){ |
1092 | 4489 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
|
4490 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4491 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
|
4492 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4493 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4494 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4495 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4496 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4497 int last=0; |
1057 | 4498 for(i=0; i<64; i++){ |
4499 int j; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4500 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4501 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4502 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4503 last= v; |
1092 | 4504 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
|
4505 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4506 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
|
4507 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4508 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4509 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4510 for(; i<64; i++){ |
1092 | 4511 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
|
4512 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4513 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
|
4514 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4515 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4516 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4517 // 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
|
4518 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4519 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4520 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4521 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
|
4522 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4523 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4524 if(!get_bits1(gb)) printf("Complexity estimation not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4525 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4526 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
|
4527 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4528 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
|
4529 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4530 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4531 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4532 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4533 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4534 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
|
4535 if(s->new_pred){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4536 printf("new pred not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4537 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
|
4538 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
|
4539 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4540 s->reduced_res_vop= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4541 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4542 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4543 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4544 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4545 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4546 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4547 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4548 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4549 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4550 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4551 GetBitContext bak= *gb; |
751 | 4552 int ref_layer_id; |
4553 int ref_layer_sampling_dir; | |
4554 int h_sampling_factor_n; | |
4555 int h_sampling_factor_m; | |
4556 int v_sampling_factor_n; | |
4557 int v_sampling_factor_m; | |
4558 | |
4559 s->hierachy_type= get_bits1(gb); | |
4560 ref_layer_id= get_bits(gb, 4); | |
4561 ref_layer_sampling_dir= get_bits1(gb); | |
4562 h_sampling_factor_n= get_bits(gb, 5); | |
4563 h_sampling_factor_m= get_bits(gb, 5); | |
4564 v_sampling_factor_n= get_bits(gb, 5); | |
4565 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
|
4566 s->enhancement_type= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4567 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4568 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4569 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4570 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4571 // 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
|
4572 s->scalability=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4573 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4574 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4575 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4576 printf("scalability not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4577 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4578 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4579 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4580 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4581 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4582 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4583 |
1034 | 4584 /** |
4585 * decodes the user data stuff in the header. | |
4586 * allso inits divx/xvid/lavc_version/build | |
4587 */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4588 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
|
4589 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4590 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4591 int e; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4592 int ver, build, ver2, ver3; |
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
|
4593 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4594 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4595 buf[0]= show_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4596 for(i=1; i<256; i++){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4597 buf[i]= show_bits(gb, 16)&0xFF; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4598 if(buf[i]==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4599 skip_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4600 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4601 buf[255]=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
|
4602 |
761 | 4603 /* 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
|
4604 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
|
4605 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
|
4606 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
|
4607 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4608 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4609 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
|
4610 s->divx_packed= e==3 && last=='p'; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4611 if(s->picture_number==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
|
4612 printf("This file was encoded with DivX%d Build%d", ver, build); |
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
|
4613 if(s->divx_packed) |
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
|
4614 printf("p\n"); |
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
|
4615 else |
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
|
4616 printf("\n"); |
263 | 4617 } |
0 | 4618 } |
761 | 4619 |
4620 /* ffmpeg detection */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4621 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4622 if(e!=4) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4623 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4624 if(e!=4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4625 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4626 s->ffmpeg_version= 0x000406; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4627 s->lavc_build= 4600; |
63 | 4628 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4629 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4630 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4631 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4632 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4633 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4634 printf("This file was encoded with libavcodec build %d\n", build); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4635 } |
761 | 4636 |
4637 /* xvid detection */ | |
4638 e=sscanf(buf, "XviD%d", &build); | |
4639 if(e==1){ | |
4640 s->xvid_build= build; | |
4641 if(s->picture_number==0) | |
4642 printf("This file was encoded with XviD build %d\n", build); | |
4643 } | |
4644 | |
255 | 4645 //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
|
4646 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4647 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4648 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4649 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
|
4650 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4651 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4652 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ |
1346 | 4653 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4654 printf("low_delay flag set, but shouldnt, clearing it\n"); |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4655 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4656 } |
753 | 4657 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4658 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
|
4659 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4660 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4661 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4662 s->decode_mb= ff_h263_decode_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4663 |
662
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4664 if(s->time_increment_resolution==0){ |
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4665 s->time_increment_resolution=1; |
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4666 // fprintf(stderr, "time_increment_resolution is illegal\n"); |
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4667 } |
262 | 4668 time_incr=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4669 while (get_bits1(gb) != 0) |
0 | 4670 time_incr++; |
4671 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4672 check_marker(gb, "before time_increment"); |
1068 | 4673 |
4674 if(s->picture_number==0 && (show_bits(gb, s->time_increment_bits+1)&1)==0){ | |
4675 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n"); | |
4676 | |
4677 | |
4678 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
4679 if(show_bits(gb, s->time_increment_bits+1)&1) break; | |
4680 } | |
4681 printf("my guess is %d bits ;)\n",s->time_increment_bits); | |
4682 } | |
4683 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4684 time_increment= get_bits(gb, s->time_increment_bits); |
697 | 4685 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment); |
262 | 4686 if(s->pict_type!=B_TYPE){ |
324 | 4687 s->last_time_base= s->time_base; |
262 | 4688 s->time_base+= time_incr; |
324 | 4689 s->time= s->time_base*s->time_increment_resolution + time_increment; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4690 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4691 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4692 // 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
|
4693 s->time_base++; |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4694 s->time+= s->time_increment_resolution; |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4695 } |
664 | 4696 } |
324 | 4697 s->pp_time= s->time - s->last_non_b_time; |
4698 s->last_non_b_time= s->time; | |
262 | 4699 }else{ |
324 | 4700 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment; |
664 | 4701 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
4702 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
335 | 4703 // printf("messed up order, seeking?, skiping current b frame\n"); |
4704 return FRAME_SKIPED; | |
4705 } | |
664 | 4706 |
4707 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base; | |
4708 if(s->t_frame==0) s->t_frame=1; // 1/0 protection | |
4709 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout); | |
4710 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) | |
4711 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
4712 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) | |
4713 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
262 | 4714 } |
654 | 4715 |
903 | 4716 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution; |
942 | 4717 if(s->avctx->debug&FF_DEBUG_PTS) |
4718 printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0)); | |
654 | 4719 |
1068 | 4720 check_marker(gb, "before vop_coded"); |
4721 | |
0 | 4722 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4723 if (get_bits1(gb) != 1){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4724 printf("vop not coded\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4725 return FRAME_SKIPED; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4726 } |
664 | 4727 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base, |
4728 //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
|
4729 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
|
4730 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { |
0 | 4731 /* rounding type for motion estimation */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4732 s->no_rounding = get_bits1(gb); |
63 | 4733 } else { |
4734 s->no_rounding = 0; | |
0 | 4735 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4736 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4737 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4738 if (s->shape != RECT_SHAPE) { |
63 | 4739 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { |
4740 int width, height, hor_spat_ref, ver_spat_ref; | |
4741 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4742 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4743 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4744 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4745 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4746 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
|
4747 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4748 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 4749 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4750 skip_bits1(gb); /* change_CR_disable */ |
63 | 4751 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4752 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4753 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 4754 } |
4755 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4756 //FIXME complexity estimation stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4757 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4758 if (s->shape != BIN_ONLY_SHAPE) { |
290 | 4759 int t; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4760 t=get_bits(gb, 3); /* intra dc VLC threshold */ |
290 | 4761 //printf("threshold %d\n", t); |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4762 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4763 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
|
4764 s->alternate_scan= get_bits1(gb); |
661 | 4765 }else |
4766 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4767 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4768 |
718 | 4769 if(s->alternate_scan){ |
1273 | 4770 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
4771 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
4772 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
4773 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 4774 } else{ |
1273 | 4775 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
4776 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
4777 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
4778 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 4779 } |
4780 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4781 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
821 | 4782 mpeg4_decode_sprite_trajectory(s); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4783 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4784 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4785 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4786 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4787 if (s->shape != BIN_ONLY_SHAPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4788 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
|
4789 if(s->qscale==0){ |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
4790 printf("Error, header damaged or not MPEG4 header (qscale=0)\n"); |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
4791 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
|
4792 } |
63 | 4793 |
4794 if (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
|
4795 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
|
4796 if(s->f_code==0){ |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
4797 printf("Error, header damaged or not MPEG4 header (f_code=0)\n"); |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
4798 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
|
4799 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4800 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4801 s->f_code=1; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4802 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4803 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
|
4804 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4805 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4806 s->b_code=1; |
906 | 4807 |
4808 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
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
|
4809 printf("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\n", |
906 | 4810 s->qscale, s->f_code, s->b_code, |
4811 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), | |
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
|
4812 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, |
930 | 4813 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, |
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
|
4814 s->sprite_warping_accuracy, 1-s->no_rounding); |
906 | 4815 } |
4816 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4817 if(!s->scalability){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4818 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
|
4819 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
|
4820 } |
575 | 4821 }else{ |
4822 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4823 int load_backward_shape= get_bits1(gb); |
575 | 4824 if(load_backward_shape){ |
4825 printf("load backward shape isnt supported\n"); | |
4826 } | |
4827 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4828 skip_bits(gb, 2); //ref_select_code |
63 | 4829 } |
4830 } | |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
4831 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/ |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
4832 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too) |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4833 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){ |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4834 printf("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
|
4835 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
4836 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
4837 |
255 | 4838 s->picture_number++; // better than pic number==0 allways ;) |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
4839 |
498 | 4840 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
4841 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
4842 | |
1137 | 4843 if(!(s->workaround_bugs&FF_BUG_EDGE)){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4844 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4845 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4846 } |
63 | 4847 return 0; |
0 | 4848 } |
4849 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4850 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4851 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4852 * @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
|
4853 * 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
|
4854 * 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
|
4855 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4856 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
|
4857 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4858 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4859 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4860 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4861 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4862 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4863 for(;;) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4864 v = get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4865 startcode = ((startcode << 8) | v) & 0xffffffff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4866 |
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
|
4867 if(get_bits_count(gb) >= gb->size_in_bits){ |
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
|
4868 if(gb->size_in_bits==8 && s->divx_version){ |
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
|
4869 printf("frame skip %d\n", gb->size_in_bits); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4870 return FRAME_SKIPED; //divx bug |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4871 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4872 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4873 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4874 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4875 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4876 continue; //no startcode |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4877 |
942 | 4878 if(s->avctx->debug&FF_DEBUG_STARTCODE){ |
4879 printf("startcode: %3X ", startcode); | |
4880 if (startcode<=0x11F) printf("Video Object Start"); | |
4881 else if(startcode<=0x12F) printf("Video Object Layer Start"); | |
4882 else if(startcode<=0x13F) printf("Reserved"); | |
4883 else if(startcode<=0x15F) printf("FGS bp start"); | |
4884 else if(startcode<=0x1AF) printf("Reserved"); | |
4885 else if(startcode==0x1B0) printf("Visual Object Seq Start"); | |
4886 else if(startcode==0x1B1) printf("Visual Object Seq End"); | |
4887 else if(startcode==0x1B2) printf("User Data"); | |
4888 else if(startcode==0x1B3) printf("Group of VOP start"); | |
4889 else if(startcode==0x1B4) printf("Video Session Error"); | |
4890 else if(startcode==0x1B5) printf("Visual Object Start"); | |
4891 else if(startcode==0x1B6) printf("Video Object Plane start"); | |
4892 else if(startcode==0x1B7) printf("slice start"); | |
4893 else if(startcode==0x1B8) printf("extension start"); | |
4894 else if(startcode==0x1B9) printf("fgs start"); | |
4895 else if(startcode==0x1BA) printf("FBA Object start"); | |
4896 else if(startcode==0x1BB) printf("FBA Object Plane start"); | |
4897 else if(startcode==0x1BC) printf("Mesh Object start"); | |
4898 else if(startcode==0x1BD) printf("Mesh Object Plane start"); | |
4899 else if(startcode==0x1BE) printf("Still Textutre Object start"); | |
4900 else if(startcode==0x1BF) printf("Textutre Spatial Layer start"); | |
4901 else if(startcode==0x1C0) printf("Textutre SNR Layer start"); | |
4902 else if(startcode==0x1C1) printf("Textutre Tile start"); | |
4903 else if(startcode==0x1C2) printf("Textutre Shape Layer start"); | |
4904 else if(startcode==0x1C3) printf("stuffing start"); | |
4905 else if(startcode<=0x1C5) printf("reserved"); | |
4906 else if(startcode<=0x1FF) printf("System start"); | |
4907 printf(" at %d\n", get_bits_count(gb)); | |
4908 } | |
4909 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4910 switch(startcode){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4911 case 0x120: |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4912 decode_vol_header(s, gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4913 break; |
942 | 4914 case USER_DATA_STARTCODE: |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4915 decode_user_data(s, gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4916 break; |
942 | 4917 case GOP_STARTCODE: |
4918 mpeg4_decode_gop_header(s, gb); | |
4919 break; | |
4920 case VOP_STARTCODE: | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4921 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
|
4922 default: |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4923 break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4924 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4925 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4926 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4927 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4928 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4929 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4930 |
0 | 4931 /* don't understand why they choose a different header ! */ |
4932 int intel_h263_decode_picture_header(MpegEncContext *s) | |
4933 { | |
4934 int format; | |
4935 | |
4936 /* picture header */ | |
1257 | 4937 if (get_bits_long(&s->gb, 22) != 0x20) { |
355 | 4938 fprintf(stderr, "Bad picture start code\n"); |
0 | 4939 return -1; |
355 | 4940 } |
4941 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 4942 |
355 | 4943 if (get_bits1(&s->gb) != 1) { |
4944 fprintf(stderr, "Bad marker\n"); | |
0 | 4945 return -1; /* marker */ |
355 | 4946 } |
4947 if (get_bits1(&s->gb) != 0) { | |
4948 fprintf(stderr, "Bad H263 id\n"); | |
0 | 4949 return -1; /* h263 id */ |
355 | 4950 } |
21 | 4951 skip_bits1(&s->gb); /* split screen off */ |
4952 skip_bits1(&s->gb); /* camera off */ | |
4953 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 4954 |
4955 format = get_bits(&s->gb, 3); | |
355 | 4956 if (format != 7) { |
4957 fprintf(stderr, "Intel H263 free format not supported\n"); | |
0 | 4958 return -1; |
355 | 4959 } |
0 | 4960 s->h263_plus = 0; |
4961 | |
21 | 4962 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 4963 |
21 | 4964 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 4965 s->h263_long_vectors = s->unrestricted_mv; |
4966 | |
355 | 4967 if (get_bits1(&s->gb) != 0) { |
4968 fprintf(stderr, "SAC not supported\n"); | |
0 | 4969 return -1; /* SAC: off */ |
355 | 4970 } |
4971 if (get_bits1(&s->gb) != 0) { | |
4972 fprintf(stderr, "Advanced Prediction Mode not supported\n"); | |
0 | 4973 return -1; /* advanced prediction mode: off */ |
355 | 4974 } |
4975 if (get_bits1(&s->gb) != 0) { | |
4976 fprintf(stderr, "PB frame mode no supported\n"); | |
4977 return -1; /* PB frame mode */ | |
4978 } | |
0 | 4979 |
4980 /* skip unknown header garbage */ | |
21 | 4981 skip_bits(&s->gb, 41); |
0 | 4982 |
4983 s->qscale = get_bits(&s->gb, 5); | |
21 | 4984 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 4985 |
4986 /* PEI */ | |
21 | 4987 while (get_bits1(&s->gb) != 0) { |
4988 skip_bits(&s->gb, 8); | |
0 | 4989 } |
4990 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
4991 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
4992 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
4993 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
|
4994 |
0 | 4995 return 0; |
4996 } | |
144 | 4997 |