Mercurial > libavcodec.hg
annotate mpeg12.c @ 1708:dea5b2946999 libavcodec
interlaced motion estimation
interlaced mpeg2 encoding
P & B frames
rate distored interlaced mb decission
alternate scantable support
4mv encoding fixes (thats also why the regression tests change)
passing height to most dsp functions
interlaced mpeg4 encoding (no direct mode MBs yet)
various related cleanups
disabled old motion estimaton algorithms (log, full, ...) they will either be fixed or removed
author | michael |
---|---|
date | Tue, 30 Dec 2003 16:07:57 +0000 |
parents | 3ba5c493db6f |
children | 4a68b20eeb2c |
rev | line source |
---|---|
0 | 1 /* |
1106 | 2 * MPEG1 codec / MPEG2 decoder |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
0 | 4 * |
429 | 5 * This library is free software; you can redistribute it and/or |
6 * modify it under the terms of the GNU Lesser General Public | |
7 * License as published by the Free Software Foundation; either | |
8 * version 2 of the License, or (at your option) any later version. | |
0 | 9 * |
429 | 10 * This library is distributed in the hope that it will be useful, |
0 | 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 * Lesser General Public License for more details. | |
0 | 14 * |
429 | 15 * You should have received a copy of the GNU Lesser General Public |
16 * License along with this library; if not, write to the Free Software | |
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
0 | 18 */ |
1106 | 19 |
20 /** | |
21 * @file mpeg12.c | |
1421 | 22 * MPEG1/2 codec |
1106 | 23 */ |
24 | |
76 | 25 //#define DEBUG |
0 | 26 #include "avcodec.h" |
27 #include "dsputil.h" | |
28 #include "mpegvideo.h" | |
29 | |
30 #include "mpeg12data.h" | |
31 | |
1708 | 32 //#undef NDEBUG |
33 //#include <assert.h> | |
34 | |
694 | 35 |
0 | 36 /* Start codes. */ |
37 #define SEQ_END_CODE 0x000001b7 | |
38 #define SEQ_START_CODE 0x000001b3 | |
39 #define GOP_START_CODE 0x000001b8 | |
40 #define PICTURE_START_CODE 0x00000100 | |
41 #define SLICE_MIN_START_CODE 0x00000101 | |
42 #define SLICE_MAX_START_CODE 0x000001af | |
43 #define EXT_START_CODE 0x000001b5 | |
44 #define USER_START_CODE 0x000001b2 | |
45 | |
552 | 46 #define DC_VLC_BITS 9 |
47 #define MV_VLC_BITS 9 | |
48 #define MBINCR_VLC_BITS 9 | |
49 #define MB_PAT_VLC_BITS 9 | |
50 #define MB_PTYPE_VLC_BITS 6 | |
51 #define MB_BTYPE_VLC_BITS 6 | |
52 #define TEX_VLC_BITS 9 | |
53 | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1503
diff
changeset
|
54 #ifdef CONFIG_ENCODERS |
0 | 55 static void mpeg1_encode_block(MpegEncContext *s, |
56 DCTELEM *block, | |
57 int component); | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
58 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1503
diff
changeset
|
59 #endif //CONFIG_ENCODERS |
0 | 60 static void mpeg1_skip_picture(MpegEncContext *s, int pict_num); |
711 | 61 static inline int mpeg1_decode_block_inter(MpegEncContext *s, |
62 DCTELEM *block, | |
63 int n); | |
64 static inline int mpeg1_decode_block_intra(MpegEncContext *s, | |
0 | 65 DCTELEM *block, |
66 int n); | |
714 | 67 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, |
0 | 68 DCTELEM *block, |
69 int n); | |
714 | 70 static inline int mpeg2_decode_block_intra(MpegEncContext *s, |
0 | 71 DCTELEM *block, |
72 int n); | |
73 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred); | |
1620 | 74 static void exchange_uv(MpegEncContext *s); |
0 | 75 |
1381 | 76 #ifdef HAVE_XVMC |
77 extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx); | |
78 extern int XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
79 extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp); |
1620 | 80 extern void XVMC_init_block(MpegEncContext *s);//set s->block |
1381 | 81 #endif |
82 | |
947 | 83 #ifdef CONFIG_ENCODERS |
1162 | 84 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL; |
1064 | 85 static uint8_t fcode_tab[MAX_MV*2+1]; |
281
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
86 |
947 | 87 static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2]; |
88 static uint8_t uni_mpeg1_ac_vlc_len [64*64*2]; | |
1325 | 89 |
90 /* simple include everything table for dc, first byte is bits number next 3 are code*/ | |
91 static uint32_t mpeg1_lum_dc_uni[512]; | |
92 static uint32_t mpeg1_chr_dc_uni[512]; | |
93 | |
94 static uint8_t mpeg1_index_run[2][64]; | |
95 static int8_t mpeg1_max_level[2][64]; | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1503
diff
changeset
|
96 #endif //CONFIG_ENCODERS |
947 | 97 |
552 | 98 static void init_2d_vlc_rl(RLTable *rl) |
99 { | |
620
a5aa53b6e648
warning patch by (Dominik Mierzejewski <dominik at rangers dot eu dot org>)
michaelni
parents:
617
diff
changeset
|
100 int i; |
552 | 101 |
102 init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, | |
103 &rl->table_vlc[0][1], 4, 2, | |
104 &rl->table_vlc[0][0], 4, 2); | |
105 | |
106 | |
107 rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); | |
108 for(i=0; i<rl->vlc.table_size; i++){ | |
109 int code= rl->vlc.table[i][0]; | |
110 int len = rl->vlc.table[i][1]; | |
111 int level, run; | |
112 | |
113 if(len==0){ // illegal code | |
114 run= 65; | |
115 level= MAX_LEVEL; | |
116 }else if(len<0){ //more bits needed | |
117 run= 0; | |
118 level= code; | |
119 }else{ | |
120 if(code==rl->n){ //esc | |
121 run= 65; | |
122 level= 0; | |
123 }else if(code==rl->n+1){ //eob | |
711 | 124 run= 0; |
125 level= 127; | |
552 | 126 }else{ |
127 run= rl->table_run [code] + 1; | |
128 level= rl->table_level[code]; | |
129 } | |
130 } | |
131 rl->rl_vlc[0][i].len= len; | |
132 rl->rl_vlc[0][i].level= level; | |
133 rl->rl_vlc[0][i].run= run; | |
134 } | |
135 } | |
136 | |
1325 | 137 #ifdef CONFIG_ENCODERS |
947 | 138 static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){ |
139 int i; | |
140 | |
141 for(i=0; i<128; i++){ | |
142 int level= i-64; | |
143 int run; | |
144 for(run=0; run<64; run++){ | |
145 int len, bits, code; | |
146 | |
147 int alevel= ABS(level); | |
148 int sign= (level>>31)&1; | |
149 | |
150 if (alevel > rl->max_level[0][run]) | |
151 code= 111; /*rl->n*/ | |
152 else | |
153 code= rl->index_run[0][run] + alevel - 1; | |
154 | |
155 if (code < 111 /* rl->n */) { | |
156 /* store the vlc & sign at once */ | |
157 len= mpeg1_vlc[code][1]+1; | |
158 bits= (mpeg1_vlc[code][0]<<1) + sign; | |
159 } else { | |
160 len= mpeg1_vlc[111/*rl->n*/][1]+6; | |
161 bits= mpeg1_vlc[111/*rl->n*/][0]<<6; | |
162 | |
163 bits|= run; | |
164 if (alevel < 128) { | |
165 bits<<=8; len+=8; | |
166 bits|= level & 0xff; | |
167 } else { | |
168 bits<<=16; len+=16; | |
169 bits|= level & 0xff; | |
170 if (level < 0) { | |
171 bits|= 0x8001 + level + 255; | |
172 } else { | |
173 bits|= level & 0xffff; | |
174 } | |
175 } | |
176 } | |
177 | |
178 uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits; | |
179 uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len; | |
180 } | |
181 } | |
182 } | |
552 | 183 |
0 | 184 static void put_header(MpegEncContext *s, int header) |
185 { | |
186 align_put_bits(&s->pb); | |
236 | 187 put_bits(&s->pb, 16, header>>16); |
188 put_bits(&s->pb, 16, header&0xFFFF); | |
0 | 189 } |
190 | |
191 /* put sequence header if needed */ | |
192 static void mpeg1_encode_sequence_header(MpegEncContext *s) | |
193 { | |
194 unsigned int vbv_buffer_size; | |
1 | 195 unsigned int fps, v; |
918 | 196 int n, i; |
1064 | 197 uint64_t time_code; |
918 | 198 float best_aspect_error= 1E10; |
1548 | 199 float aspect_ratio= av_q2d(s->avctx->sample_aspect_ratio); |
1479 | 200 int constraint_parameter_flag; |
918 | 201 |
1548 | 202 if(aspect_ratio==0.0) aspect_ratio= 1.0; //pixel aspect 1:1 (VGA) |
0 | 203 |
903 | 204 if (s->current_picture.key_frame) { |
0 | 205 /* mpeg1 header repeated every gop */ |
206 put_header(s, SEQ_START_CODE); | |
207 | |
208 /* search closest frame rate */ | |
209 { | |
210 int i, dmin, d; | |
211 s->frame_rate_index = 0; | |
212 dmin = 0x7fffffff; | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
213 for(i=1;i<14;i++) { |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
214 if(s->avctx->strict_std_compliance >= 0 && i>=9) break; |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
215 |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
216 d = abs(MPEG1_FRAME_RATE_BASE*(int64_t)s->avctx->frame_rate/s->avctx->frame_rate_base - frame_rate_tab[i]); |
0 | 217 if (d < dmin) { |
218 dmin = d; | |
219 s->frame_rate_index = i; | |
220 } | |
221 } | |
222 } | |
223 | |
224 put_bits(&s->pb, 12, s->width); | |
225 put_bits(&s->pb, 12, s->height); | |
918 | 226 |
227 for(i=1; i<15; i++){ | |
1550 | 228 float error= aspect_ratio; |
229 if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1) | |
1587
b69b086f5570
100l (SAR is written as height/width instead of width/height in the MPEG1 standard)
michael
parents:
1580
diff
changeset
|
230 error-= 1.0/mpeg1_aspect[i]; |
1550 | 231 else |
232 error-= av_q2d(mpeg2_aspect[i])*s->height/s->width; | |
233 | |
918 | 234 error= ABS(error); |
235 | |
236 if(error < best_aspect_error){ | |
237 best_aspect_error= error; | |
238 s->aspect_ratio_info= i; | |
239 } | |
240 } | |
241 | |
242 put_bits(&s->pb, 4, s->aspect_ratio_info); | |
0 | 243 put_bits(&s->pb, 4, s->frame_rate_index); |
1430
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
244 |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
245 if(s->avctx->rc_max_rate){ |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
246 v = (s->avctx->rc_max_rate + 399) / 400; |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
247 if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO) |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
248 v = 0x3ffff; |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
249 }else{ |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
250 v= 0x3FFFF; |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
251 } |
639
f449913e8419
new vbv calculation patch by (Henry Mason <talus25 at speakeasy dot net>) with slight modification by me
michaelni
parents:
620
diff
changeset
|
252 |
f449913e8419
new vbv calculation patch by (Henry Mason <talus25 at speakeasy dot net>) with slight modification by me
michaelni
parents:
620
diff
changeset
|
253 if(s->avctx->rc_buffer_size) |
f449913e8419
new vbv calculation patch by (Henry Mason <talus25 at speakeasy dot net>) with slight modification by me
michaelni
parents:
620
diff
changeset
|
254 vbv_buffer_size = s->avctx->rc_buffer_size; |
f449913e8419
new vbv calculation patch by (Henry Mason <talus25 at speakeasy dot net>) with slight modification by me
michaelni
parents:
620
diff
changeset
|
255 else |
f449913e8419
new vbv calculation patch by (Henry Mason <talus25 at speakeasy dot net>) with slight modification by me
michaelni
parents:
620
diff
changeset
|
256 /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */ |
1430
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
257 vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024; |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
258 vbv_buffer_size= (vbv_buffer_size + 16383) / 16384; |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
259 |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
260 put_bits(&s->pb, 18, v & 0x3FFFF); |
248d9ae1033c
bit_rate in mpeg1/2 should be 0x3FFFF for vbr or at least >= max_bitrate
michaelni
parents:
1429
diff
changeset
|
261 put_bits(&s->pb, 1, 1); /* marker */ |
1479 | 262 put_bits(&s->pb, 10, vbv_buffer_size & 0x3FF); |
263 | |
264 constraint_parameter_flag= | |
265 s->width <= 768 && s->height <= 576 && | |
266 s->mb_width * s->mb_height <= 396 && | |
267 s->mb_width * s->mb_height * frame_rate_tab[s->frame_rate_index] <= MPEG1_FRAME_RATE_BASE*396*25 && | |
268 frame_rate_tab[s->frame_rate_index] <= MPEG1_FRAME_RATE_BASE*30 && | |
269 vbv_buffer_size <= 20 && | |
270 v <= 1856000/400 && | |
271 s->codec_id == CODEC_ID_MPEG1VIDEO; | |
272 | |
273 put_bits(&s->pb, 1, constraint_parameter_flag); | |
1411 | 274 |
275 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
276 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
0 | 277 |
1421 | 278 if(s->codec_id == CODEC_ID_MPEG2VIDEO){ |
279 put_header(s, EXT_START_CODE); | |
280 put_bits(&s->pb, 4, 1); //seq ext | |
281 put_bits(&s->pb, 1, 0); //esc | |
282 put_bits(&s->pb, 3, 4); //profile | |
283 put_bits(&s->pb, 4, 8); //level | |
1677 | 284 put_bits(&s->pb, 1, s->progressive_sequence); |
1421 | 285 put_bits(&s->pb, 2, 1); //chroma format 4:2:0 |
286 put_bits(&s->pb, 2, 0); //horizontal size ext | |
287 put_bits(&s->pb, 2, 0); //vertical size ext | |
288 put_bits(&s->pb, 12, v>>18); //bitrate ext | |
289 put_bits(&s->pb, 1, 1); //marker | |
290 put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext | |
291 put_bits(&s->pb, 1, s->low_delay); | |
292 put_bits(&s->pb, 2, 0); // frame_rate_ext_n | |
293 put_bits(&s->pb, 5, 0); // frame_rate_ext_d | |
294 } | |
295 | |
0 | 296 put_header(s, GOP_START_CODE); |
297 put_bits(&s->pb, 1, 0); /* do drop frame */ | |
298 /* time code : we must convert from the real frame rate to a | |
299 fake mpeg frame rate in case of low frame rate */ | |
300 fps = frame_rate_tab[s->frame_rate_index]; | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
301 time_code = (int64_t)s->fake_picture_number * MPEG1_FRAME_RATE_BASE; |
0 | 302 s->gop_picture_number = s->fake_picture_number; |
1064 | 303 put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24)); |
304 put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60)); | |
0 | 305 put_bits(&s->pb, 1, 1); |
1064 | 306 put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60)); |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
307 put_bits(&s->pb, 6, (uint32_t)((time_code % fps) / MPEG1_FRAME_RATE_BASE)); |
1429 | 308 put_bits(&s->pb, 1, 0); /* closed gop */ |
0 | 309 put_bits(&s->pb, 1, 0); /* broken link */ |
310 } | |
311 | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
312 if (s->avctx->frame_rate < (24 * s->avctx->frame_rate_base) && s->picture_number > 0) { |
0 | 313 /* insert empty P pictures to slow down to the desired |
314 frame rate. Each fake pictures takes about 20 bytes */ | |
315 fps = frame_rate_tab[s->frame_rate_index]; | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
316 n = av_rescale((int64_t)s->picture_number * s->avctx->frame_rate_base, fps, s->avctx->frame_rate) / MPEG1_FRAME_RATE_BASE - 1; |
0 | 317 while (s->fake_picture_number < n) { |
318 mpeg1_skip_picture(s, s->fake_picture_number - | |
319 s->gop_picture_number); | |
320 s->fake_picture_number++; | |
321 } | |
322 | |
323 } | |
324 } | |
325 | |
1160 | 326 static inline void encode_mb_skip_run(MpegEncContext *s, int run){ |
327 while (run >= 33) { | |
328 put_bits(&s->pb, 11, 0x008); | |
329 run -= 33; | |
330 } | |
331 put_bits(&s->pb, mbAddrIncrTable[run][1], | |
332 mbAddrIncrTable[run][0]); | |
333 } | |
0 | 334 |
335 /* insert a fake P picture */ | |
336 static void mpeg1_skip_picture(MpegEncContext *s, int pict_num) | |
337 { | |
1421 | 338 assert(s->codec_id == CODEC_ID_MPEG1VIDEO); // mpeg2 can do these repeat things |
339 | |
0 | 340 /* mpeg1 picture header */ |
341 put_header(s, PICTURE_START_CODE); | |
342 /* temporal reference */ | |
343 put_bits(&s->pb, 10, pict_num & 0x3ff); | |
344 | |
345 put_bits(&s->pb, 3, P_TYPE); | |
346 put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */ | |
347 | |
348 put_bits(&s->pb, 1, 1); /* integer coordinates */ | |
349 put_bits(&s->pb, 3, 1); /* forward_f_code */ | |
350 | |
351 put_bits(&s->pb, 1, 0); /* extra bit picture */ | |
352 | |
353 /* only one slice */ | |
354 put_header(s, SLICE_MIN_START_CODE); | |
355 put_bits(&s->pb, 5, 1); /* quantizer scale */ | |
356 put_bits(&s->pb, 1, 0); /* slice extra information */ | |
357 | |
1160 | 358 encode_mb_skip_run(s, 0); |
0 | 359 |
360 /* empty macroblock */ | |
361 put_bits(&s->pb, 3, 1); /* motion only */ | |
362 | |
363 /* zero motion x & y */ | |
364 put_bits(&s->pb, 1, 1); | |
365 put_bits(&s->pb, 1, 1); | |
366 | |
367 /* output a number of empty slice */ | |
1160 | 368 encode_mb_skip_run(s, s->mb_width * s->mb_height - 2); |
0 | 369 |
370 /* empty macroblock */ | |
371 put_bits(&s->pb, 3, 1); /* motion only */ | |
372 | |
373 /* zero motion x & y */ | |
374 put_bits(&s->pb, 1, 1); | |
375 put_bits(&s->pb, 1, 1); | |
376 } | |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1503
diff
changeset
|
377 #endif //CONFIG_ENCODERS |
0 | 378 |
498 | 379 static void common_init(MpegEncContext *s) |
380 { | |
381 s->y_dc_scale_table= | |
382 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
383 } | |
384 | |
1325 | 385 void ff_mpeg1_clean_buffers(MpegEncContext *s){ |
386 s->last_dc[0] = 1 << (7 + s->intra_dc_precision); | |
387 s->last_dc[1] = s->last_dc[0]; | |
388 s->last_dc[2] = s->last_dc[0]; | |
389 memset(s->last_mv, 0, sizeof(s->last_mv)); | |
390 } | |
391 | |
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:
1064
diff
changeset
|
392 #ifdef CONFIG_ENCODERS |
1160 | 393 |
394 void ff_mpeg1_encode_slice_header(MpegEncContext *s){ | |
395 put_header(s, SLICE_MIN_START_CODE + s->mb_y); | |
396 put_bits(&s->pb, 5, s->qscale); /* quantizer scale */ | |
397 put_bits(&s->pb, 1, 0); /* slice extra information */ | |
398 } | |
399 | |
0 | 400 void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) |
401 { | |
402 mpeg1_encode_sequence_header(s); | |
403 | |
404 /* mpeg1 picture header */ | |
405 put_header(s, PICTURE_START_CODE); | |
406 /* temporal reference */ | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
407 |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
408 // RAL: s->picture_number instead of s->fake_picture_number |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
409 put_bits(&s->pb, 10, (s->picture_number - |
0 | 410 s->gop_picture_number) & 0x3ff); |
276
1e2f9ef286d4
- Fix pts calculation on mpeg mux (A/V sync) - Thanks to Lennert Buytenhek
pulento
parents:
275
diff
changeset
|
411 s->fake_picture_number++; |
0 | 412 |
413 put_bits(&s->pb, 3, s->pict_type); | |
1697 | 414 |
415 s->vbv_delay_ptr= s->pb.buf + get_bit_count(&s->pb)/8; | |
416 put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */ | |
0 | 417 |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
418 // RAL: Forward f_code also needed for B frames |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
419 if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) { |
0 | 420 put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
1432 | 421 if(s->codec_id == CODEC_ID_MPEG1VIDEO) |
422 put_bits(&s->pb, 3, s->f_code); /* forward_f_code */ | |
423 else | |
424 put_bits(&s->pb, 3, 7); /* forward_f_code */ | |
0 | 425 } |
426 | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
427 // RAL: Backward f_code necessary for B frames |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
428 if (s->pict_type == B_TYPE) { |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
429 put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
1432 | 430 if(s->codec_id == CODEC_ID_MPEG1VIDEO) |
431 put_bits(&s->pb, 3, s->b_code); /* backward_f_code */ | |
432 else | |
433 put_bits(&s->pb, 3, 7); /* backward_f_code */ | |
1421 | 434 } |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
435 |
0 | 436 put_bits(&s->pb, 1, 0); /* extra bit picture */ |
1677 | 437 |
438 s->frame_pred_frame_dct = 1; | |
1421 | 439 if(s->codec_id == CODEC_ID_MPEG2VIDEO){ |
440 put_header(s, EXT_START_CODE); | |
441 put_bits(&s->pb, 4, 8); //pic ext | |
1432 | 442 if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) { |
443 put_bits(&s->pb, 4, s->f_code); | |
444 put_bits(&s->pb, 4, s->f_code); | |
445 }else{ | |
446 put_bits(&s->pb, 8, 255); | |
447 } | |
448 if (s->pict_type == B_TYPE) { | |
449 put_bits(&s->pb, 4, s->b_code); | |
450 put_bits(&s->pb, 4, s->b_code); | |
451 }else{ | |
452 put_bits(&s->pb, 8, 255); | |
453 } | |
1421 | 454 put_bits(&s->pb, 2, s->intra_dc_precision); |
455 put_bits(&s->pb, 2, s->picture_structure= PICT_FRAME); | |
1682 | 456 if (s->progressive_sequence) { |
457 put_bits(&s->pb, 1, 0); /* no repeat */ | |
458 } else { | |
459 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); | |
460 } | |
1677 | 461 /* XXX: optimize the generation of this flag with entropy |
462 measures */ | |
463 s->frame_pred_frame_dct = s->progressive_sequence; | |
464 | |
465 put_bits(&s->pb, 1, s->frame_pred_frame_dct); | |
1421 | 466 put_bits(&s->pb, 1, s->concealment_motion_vectors); |
467 put_bits(&s->pb, 1, s->q_scale_type); | |
468 put_bits(&s->pb, 1, s->intra_vlc_format); | |
469 put_bits(&s->pb, 1, s->alternate_scan); | |
470 put_bits(&s->pb, 1, s->repeat_first_field); | |
471 put_bits(&s->pb, 1, s->chroma_420_type=1); | |
1677 | 472 s->progressive_frame = s->progressive_sequence; |
473 put_bits(&s->pb, 1, s->progressive_frame); | |
1421 | 474 put_bits(&s->pb, 1, 0); //composite_display_flag |
475 } | |
476 | |
1160 | 477 s->mb_y=0; |
478 ff_mpeg1_encode_slice_header(s); | |
0 | 479 } |
480 | |
1677 | 481 static inline void put_mb_modes(MpegEncContext *s, int n, int bits, |
1708 | 482 int has_mv, int field_motion) |
1677 | 483 { |
484 put_bits(&s->pb, n, bits); | |
485 if (!s->frame_pred_frame_dct) { | |
486 if (has_mv) | |
1708 | 487 put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */ |
1677 | 488 put_bits(&s->pb, 1, s->interlaced_dct); |
489 } | |
490 } | |
491 | |
0 | 492 void mpeg1_encode_mb(MpegEncContext *s, |
493 DCTELEM block[6][64], | |
494 int motion_x, int motion_y) | |
495 { | |
1160 | 496 int i, cbp; |
497 const int mb_x = s->mb_x; | |
498 const int mb_y = s->mb_y; | |
499 const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y; | |
0 | 500 |
501 /* compute cbp */ | |
502 cbp = 0; | |
503 for(i=0;i<6;i++) { | |
504 if (s->block_last_index[i] >= 0) | |
505 cbp |= 1 << (5 - i); | |
506 } | |
1708 | 507 |
1421 | 508 if (cbp == 0 && !first_mb && (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) && |
1708 | 509 ((s->pict_type == P_TYPE && s->mv_type == MV_TYPE_16X16 && (motion_x | motion_y) == 0) || |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
510 (s->pict_type == B_TYPE && s->mv_dir == s->last_mv_dir && (((s->mv_dir & MV_DIR_FORWARD) ? ((s->mv[0][0][0] - s->last_mv[0][0][0])|(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) | |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
511 ((s->mv_dir & MV_DIR_BACKWARD) ? ((s->mv[1][0][0] - s->last_mv[1][0][0])|(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) { |
1160 | 512 s->mb_skip_run++; |
694 | 513 s->qscale -= s->dquant; |
740 | 514 s->skip_count++; |
515 s->misc_bits++; | |
516 s->last_bits++; | |
1708 | 517 if(s->pict_type == P_TYPE){ |
518 s->last_mv[0][1][0]= s->last_mv[0][0][0]= | |
519 s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0; | |
520 } | |
0 | 521 } else { |
1160 | 522 if(first_mb){ |
523 assert(s->mb_skip_run == 0); | |
524 encode_mb_skip_run(s, s->mb_x); | |
525 }else{ | |
526 encode_mb_skip_run(s, s->mb_skip_run); | |
0 | 527 } |
528 | |
529 if (s->pict_type == I_TYPE) { | |
694 | 530 if(s->dquant && cbp){ |
1708 | 531 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */ |
694 | 532 put_bits(&s->pb, 5, s->qscale); |
533 }else{ | |
1708 | 534 put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */ |
694 | 535 s->qscale -= s->dquant; |
536 } | |
740 | 537 s->misc_bits+= get_bits_diff(s); |
538 s->i_count++; | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
539 } else if (s->mb_intra) { |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
540 if(s->dquant && cbp){ |
1708 | 541 put_mb_modes(s, 6, 0x01, 0, 0); |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
542 put_bits(&s->pb, 5, s->qscale); |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
543 }else{ |
1708 | 544 put_mb_modes(s, 5, 0x03, 0, 0); |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
545 s->qscale -= s->dquant; |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
546 } |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
547 s->misc_bits+= get_bits_diff(s); |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
548 s->i_count++; |
1708 | 549 memset(s->last_mv, 0, sizeof(s->last_mv)); |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
550 } else if (s->pict_type == P_TYPE) { |
1708 | 551 if(s->mv_type == MV_TYPE_16X16){ |
0 | 552 if (cbp != 0) { |
1708 | 553 if ((motion_x|motion_y) == 0) { |
694 | 554 if(s->dquant){ |
1708 | 555 put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */ |
694 | 556 put_bits(&s->pb, 5, s->qscale); |
557 }else{ | |
1708 | 558 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */ |
694 | 559 } |
740 | 560 s->misc_bits+= get_bits_diff(s); |
0 | 561 } else { |
694 | 562 if(s->dquant){ |
1708 | 563 put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */ |
694 | 564 put_bits(&s->pb, 5, s->qscale); |
565 }else{ | |
1708 | 566 put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */ |
694 | 567 } |
740 | 568 s->misc_bits+= get_bits_diff(s); |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
569 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
570 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added |
740 | 571 s->mv_bits+= get_bits_diff(s); |
0 | 572 } |
573 } else { | |
574 put_bits(&s->pb, 3, 1); /* motion only */ | |
1677 | 575 if (!s->frame_pred_frame_dct) |
576 put_bits(&s->pb, 2, 2); /* motion_type: frame */ | |
1708 | 577 s->misc_bits+= get_bits_diff(s); |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
578 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
579 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added |
694 | 580 s->qscale -= s->dquant; |
740 | 581 s->mv_bits+= get_bits_diff(s); |
0 | 582 } |
1708 | 583 s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x; |
584 s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y; | |
585 }else{ | |
586 assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD); | |
587 | |
588 if (cbp) { | |
589 if(s->dquant){ | |
590 put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */ | |
591 put_bits(&s->pb, 5, s->qscale); | |
592 }else{ | |
593 put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */ | |
594 } | |
595 } else { | |
596 put_bits(&s->pb, 3, 1); /* motion only */ | |
597 put_bits(&s->pb, 2, 1); /* motion_type: field */ | |
598 s->qscale -= s->dquant; | |
599 } | |
600 s->misc_bits+= get_bits_diff(s); | |
601 for(i=0; i<2; i++){ | |
602 put_bits(&s->pb, 1, s->field_select[0][i]); | |
603 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); | |
604 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); | |
605 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
606 s->last_mv[0][i][1]= 2*s->mv[0][i][1]; | |
607 } | |
608 s->mv_bits+= get_bits_diff(s); | |
609 } | |
610 if(cbp) | |
611 put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]); | |
612 s->f_count++; | |
613 } else{ | |
614 static const int mb_type_len[4]={0,3,4,2}; //bak,for,bi | |
615 | |
616 if(s->mv_type == MV_TYPE_16X16){ | |
617 if (cbp){ // With coded bloc pattern | |
618 if (s->dquant) { | |
619 if(s->mv_dir == MV_DIR_FORWARD) | |
620 put_mb_modes(s, 6, 3, 1, 0); | |
621 else | |
622 put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 0); | |
623 put_bits(&s->pb, 5, s->qscale); | |
624 } else { | |
625 put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 0); | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
626 } |
1708 | 627 }else{ // No coded bloc pattern |
628 put_bits(&s->pb, mb_type_len[s->mv_dir], 2); | |
629 if (!s->frame_pred_frame_dct) | |
630 put_bits(&s->pb, 2, 2); /* motion_type: frame */ | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
631 s->qscale -= s->dquant; |
1708 | 632 } |
633 s->misc_bits += get_bits_diff(s); | |
634 if (s->mv_dir&MV_DIR_FORWARD){ | |
635 mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); | |
636 mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
637 s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0]; | |
638 s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1]; | |
639 s->f_count++; | |
640 } | |
641 if (s->mv_dir&MV_DIR_BACKWARD){ | |
642 mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); | |
643 mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
644 s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0]; | |
645 s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1]; | |
646 s->b_count++; | |
647 } | |
648 }else{ | |
649 assert(s->mv_type == MV_TYPE_FIELD); | |
650 assert(!s->frame_pred_frame_dct); | |
651 if (cbp){ // With coded bloc pattern | |
652 if (s->dquant) { | |
653 if(s->mv_dir == MV_DIR_FORWARD) | |
654 put_mb_modes(s, 6, 3, 1, 1); | |
655 else | |
656 put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 1); | |
657 put_bits(&s->pb, 5, s->qscale); | |
658 } else { | |
659 put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 1); | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
660 } |
1708 | 661 }else{ // No coded bloc pattern |
662 put_bits(&s->pb, mb_type_len[s->mv_dir], 2); | |
663 put_bits(&s->pb, 2, 1); /* motion_type: field */ | |
664 s->qscale -= s->dquant; | |
665 } | |
666 s->misc_bits += get_bits_diff(s); | |
667 if (s->mv_dir&MV_DIR_FORWARD){ | |
668 for(i=0; i<2; i++){ | |
669 put_bits(&s->pb, 1, s->field_select[0][i]); | |
670 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); | |
671 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); | |
672 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
673 s->last_mv[0][i][1]= 2*s->mv[0][i][1]; | |
674 } | |
675 s->f_count++; | |
676 } | |
677 if (s->mv_dir&MV_DIR_BACKWARD){ | |
678 for(i=0; i<2; i++){ | |
679 put_bits(&s->pb, 1, s->field_select[1][i]); | |
680 mpeg1_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code); | |
681 mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code); | |
682 s->last_mv[1][i][0]= s->mv[1][i][0]; | |
683 s->last_mv[1][i][1]= 2*s->mv[1][i][1]; | |
684 } | |
685 s->b_count++; | |
686 } | |
0 | 687 } |
1708 | 688 s->mv_bits += get_bits_diff(s); |
689 if(cbp) | |
690 put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]); | |
691 } | |
0 | 692 for(i=0;i<6;i++) { |
693 if (cbp & (1 << (5 - i))) { | |
694 mpeg1_encode_block(s, block[i], i); | |
695 } | |
696 } | |
1160 | 697 s->mb_skip_run = 0; |
740 | 698 if(s->mb_intra) |
699 s->i_tex_bits+= get_bits_diff(s); | |
700 else | |
701 s->p_tex_bits+= get_bits_diff(s); | |
0 | 702 } |
703 } | |
704 | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
705 // RAL: Parameter added: f_or_b_code |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
706 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code) |
0 | 707 { |
708 int code, bit_size, l, m, bits, range, sign; | |
709 | |
710 if (val == 0) { | |
711 /* zero vector */ | |
712 code = 0; | |
713 put_bits(&s->pb, | |
714 mbMotionVectorTable[0][1], | |
715 mbMotionVectorTable[0][0]); | |
716 } else { | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
717 bit_size = f_or_b_code - 1; |
0 | 718 range = 1 << bit_size; |
719 /* modulo encoding */ | |
720 l = 16 * range; | |
721 m = 2 * l; | |
722 if (val < -l) { | |
723 val += m; | |
724 } else if (val >= l) { | |
725 val -= m; | |
726 } | |
727 | |
728 if (val >= 0) { | |
729 val--; | |
730 code = (val >> bit_size) + 1; | |
731 bits = val & (range - 1); | |
732 sign = 0; | |
733 } else { | |
734 val = -val; | |
735 val--; | |
736 code = (val >> bit_size) + 1; | |
737 bits = val & (range - 1); | |
738 sign = 1; | |
739 } | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
740 |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
741 assert(code > 0 && code <= 16); |
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
742 |
0 | 743 put_bits(&s->pb, |
744 mbMotionVectorTable[code][1], | |
745 mbMotionVectorTable[code][0]); | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1025
diff
changeset
|
746 |
0 | 747 put_bits(&s->pb, 1, sign); |
748 if (bit_size > 0) { | |
749 put_bits(&s->pb, bit_size, bits); | |
750 } | |
751 } | |
752 } | |
753 | |
498 | 754 void ff_mpeg1_encode_init(MpegEncContext *s) |
281
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
755 { |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
756 static int done=0; |
498 | 757 |
758 common_init(s); | |
759 | |
281
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
760 if(!done){ |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
761 int f_code; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
762 int mv; |
498 | 763 int i; |
281
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
764 |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
765 done=1; |
498 | 766 init_rl(&rl_mpeg1); |
947 | 767 |
498 | 768 for(i=0; i<64; i++) |
769 { | |
770 mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i]; | |
771 mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i]; | |
772 } | |
947 | 773 |
774 init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len); | |
498 | 775 |
776 /* build unified dc encoding tables */ | |
777 for(i=-255; i<256; i++) | |
778 { | |
779 int adiff, index; | |
780 int bits, code; | |
781 int diff=i; | |
782 | |
783 adiff = ABS(diff); | |
784 if(diff<0) diff--; | |
785 index = vlc_dc_table[adiff]; | |
786 | |
787 bits= vlc_dc_lum_bits[index] + index; | |
788 code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1)); | |
789 mpeg1_lum_dc_uni[i+255]= bits + (code<<8); | |
790 | |
791 bits= vlc_dc_chroma_bits[index] + index; | |
792 code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1)); | |
793 mpeg1_chr_dc_uni[i+255]= bits + (code<<8); | |
794 } | |
795 | |
1162 | 796 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); |
797 | |
281
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
798 for(f_code=1; f_code<=MAX_FCODE; f_code++){ |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
799 for(mv=-MAX_MV; mv<=MAX_MV; mv++){ |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
800 int len; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
801 |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
802 if(mv==0) len= mbMotionVectorTable[0][1]; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
803 else{ |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
804 int val, bit_size, range, code; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
805 |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
806 bit_size = s->f_code - 1; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
807 range = 1 << bit_size; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
808 |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
809 val=mv; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
810 if (val < 0) |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
811 val = -val; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
812 val--; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
813 code = (val >> bit_size) + 1; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
814 if(code<17){ |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
815 len= mbMotionVectorTable[code][1] + 1 + bit_size; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
816 }else{ |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
817 len= mbMotionVectorTable[16][1] + 2 + bit_size; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
818 } |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
819 } |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
820 |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
821 mv_penalty[f_code][mv+MAX_MV]= len; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
822 } |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
823 } |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
824 |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
825 |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
826 for(f_code=MAX_FCODE; f_code>0; f_code--){ |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
827 for(mv=-(8<<f_code); mv<(8<<f_code); mv++){ |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
828 fcode_tab[mv+MAX_MV]= f_code; |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
829 } |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
830 } |
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
831 } |
936 | 832 s->me.mv_penalty= mv_penalty; |
281
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
833 s->fcode_tab= fcode_tab; |
1421 | 834 if(s->codec_id == CODEC_ID_MPEG1VIDEO){ |
835 s->min_qcoeff=-255; | |
836 s->max_qcoeff= 255; | |
837 }else{ | |
838 s->min_qcoeff=-2047; | |
839 s->max_qcoeff= 2047; | |
840 } | |
947 | 841 s->intra_ac_vlc_length= |
1503 | 842 s->inter_ac_vlc_length= |
843 s->intra_ac_vlc_last_length= | |
844 s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; | |
281
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
845 } |
498 | 846 |
0 | 847 static inline void encode_dc(MpegEncContext *s, int diff, int component) |
848 { | |
849 if (component == 0) { | |
237
75123d30f862
optimized encode_dc() (+2% speed on P3 for mpeg1 intra only encodings)
michaelni
parents:
236
diff
changeset
|
850 put_bits( |
75123d30f862
optimized encode_dc() (+2% speed on P3 for mpeg1 intra only encodings)
michaelni
parents:
236
diff
changeset
|
851 &s->pb, |
75123d30f862
optimized encode_dc() (+2% speed on P3 for mpeg1 intra only encodings)
michaelni
parents:
236
diff
changeset
|
852 mpeg1_lum_dc_uni[diff+255]&0xFF, |
75123d30f862
optimized encode_dc() (+2% speed on P3 for mpeg1 intra only encodings)
michaelni
parents:
236
diff
changeset
|
853 mpeg1_lum_dc_uni[diff+255]>>8); |
0 | 854 } else { |
237
75123d30f862
optimized encode_dc() (+2% speed on P3 for mpeg1 intra only encodings)
michaelni
parents:
236
diff
changeset
|
855 put_bits( |
75123d30f862
optimized encode_dc() (+2% speed on P3 for mpeg1 intra only encodings)
michaelni
parents:
236
diff
changeset
|
856 &s->pb, |
75123d30f862
optimized encode_dc() (+2% speed on P3 for mpeg1 intra only encodings)
michaelni
parents:
236
diff
changeset
|
857 mpeg1_chr_dc_uni[diff+255]&0xFF, |
75123d30f862
optimized encode_dc() (+2% speed on P3 for mpeg1 intra only encodings)
michaelni
parents:
236
diff
changeset
|
858 mpeg1_chr_dc_uni[diff+255]>>8); |
0 | 859 } |
860 } | |
861 | |
862 static void mpeg1_encode_block(MpegEncContext *s, | |
863 DCTELEM *block, | |
864 int n) | |
865 { | |
866 int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign; | |
867 int code, component; | |
236 | 868 // RLTable *rl = &rl_mpeg1; |
0 | 869 |
870 last_index = s->block_last_index[n]; | |
871 | |
872 /* DC coef */ | |
873 if (s->mb_intra) { | |
874 component = (n <= 3 ? 0 : n - 4 + 1); | |
875 dc = block[0]; /* overflow is impossible */ | |
876 diff = dc - s->last_dc[component]; | |
877 encode_dc(s, diff, component); | |
878 s->last_dc[component] = dc; | |
879 i = 1; | |
1421 | 880 /* |
881 if (s->intra_vlc_format) | |
882 rl = &rl_mpeg2; | |
883 else | |
884 rl = &rl_mpeg1; | |
885 */ | |
0 | 886 } else { |
887 /* encode the first coefficient : needs to be done here because | |
888 it is handled slightly differently */ | |
889 level = block[0]; | |
890 if (abs(level) == 1) { | |
1064 | 891 code = ((uint32_t)level >> 31); /* the sign bit */ |
0 | 892 put_bits(&s->pb, 2, code | 0x02); |
893 i = 1; | |
894 } else { | |
895 i = 0; | |
896 last_non_zero = -1; | |
897 goto next_coef; | |
898 } | |
899 } | |
900 | |
901 /* now quantify & encode AC coefs */ | |
902 last_non_zero = i - 1; | |
236 | 903 |
0 | 904 for(;i<=last_index;i++) { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
905 j = s->intra_scantable.permutated[i]; |
0 | 906 level = block[j]; |
907 next_coef: | |
908 #if 0 | |
909 if (level != 0) | |
910 dprintf("level[%d]=%d\n", i, level); | |
911 #endif | |
912 /* encode using VLC */ | |
913 if (level != 0) { | |
914 run = i - last_non_zero - 1; | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
915 |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
916 alevel= level; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
917 MASK_ABS(sign, alevel) |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
918 sign&=1; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
919 |
236 | 920 // code = get_rl_index(rl, 0, run, alevel); |
947 | 921 if (alevel <= mpeg1_max_level[0][run]){ |
236 | 922 code= mpeg1_index_run[0][run] + alevel - 1; |
923 /* store the vlc & sign at once */ | |
924 put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign); | |
0 | 925 } else { |
236 | 926 /* escape seems to be pretty rare <5% so i dont optimize it */ |
927 put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]); | |
0 | 928 /* escape: only clip in this case */ |
929 put_bits(&s->pb, 6, run); | |
1421 | 930 if(s->codec_id == CODEC_ID_MPEG1VIDEO){ |
931 if (alevel < 128) { | |
932 put_bits(&s->pb, 8, level & 0xff); | |
0 | 933 } else { |
1421 | 934 if (level < 0) { |
935 put_bits(&s->pb, 16, 0x8001 + level + 255); | |
936 } else { | |
937 put_bits(&s->pb, 16, level & 0xffff); | |
938 } | |
0 | 939 } |
1421 | 940 }else{ |
941 put_bits(&s->pb, 12, level & 0xfff); | |
0 | 942 } |
943 } | |
944 last_non_zero = i; | |
945 } | |
946 } | |
947 /* end of block */ | |
948 put_bits(&s->pb, 2, 0x2); | |
949 } | |
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:
1064
diff
changeset
|
950 #endif //CONFIG_ENCODERS |
0 | 951 |
952 /******************************************/ | |
953 /* decoding */ | |
954 | |
955 static VLC dc_lum_vlc; | |
956 static VLC dc_chroma_vlc; | |
957 static VLC mv_vlc; | |
958 static VLC mbincr_vlc; | |
959 static VLC mb_ptype_vlc; | |
960 static VLC mb_btype_vlc; | |
961 static VLC mb_pat_vlc; | |
962 | |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
963 static void init_vlcs() |
0 | 964 { |
965 static int done = 0; | |
966 | |
967 if (!done) { | |
494 | 968 done = 1; |
0 | 969 |
568 | 970 init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, |
0 | 971 vlc_dc_lum_bits, 1, 1, |
972 vlc_dc_lum_code, 2, 2); | |
568 | 973 init_vlc(&dc_chroma_vlc, DC_VLC_BITS, 12, |
0 | 974 vlc_dc_chroma_bits, 1, 1, |
975 vlc_dc_chroma_code, 2, 2); | |
545 | 976 init_vlc(&mv_vlc, MV_VLC_BITS, 17, |
0 | 977 &mbMotionVectorTable[0][1], 2, 1, |
978 &mbMotionVectorTable[0][0], 2, 1); | |
1181 | 979 init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36, |
0 | 980 &mbAddrIncrTable[0][1], 2, 1, |
981 &mbAddrIncrTable[0][0], 2, 1); | |
545 | 982 init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, |
0 | 983 &mbPatTable[0][1], 2, 1, |
984 &mbPatTable[0][0], 2, 1); | |
985 | |
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:
1164
diff
changeset
|
986 init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7, |
0 | 987 &table_mb_ptype[0][1], 2, 1, |
988 &table_mb_ptype[0][0], 2, 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:
1164
diff
changeset
|
989 init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11, |
0 | 990 &table_mb_btype[0][1], 2, 1, |
991 &table_mb_btype[0][0], 2, 1); | |
992 init_rl(&rl_mpeg1); | |
993 init_rl(&rl_mpeg2); | |
552 | 994 |
995 init_2d_vlc_rl(&rl_mpeg1); | |
996 init_2d_vlc_rl(&rl_mpeg2); | |
0 | 997 } |
998 } | |
999 | |
1000 static inline int get_dmv(MpegEncContext *s) | |
1001 { | |
21 | 1002 if(get_bits1(&s->gb)) |
1003 return 1 - (get_bits1(&s->gb) << 1); | |
0 | 1004 else |
1005 return 0; | |
1006 } | |
1007 | |
54 | 1008 static inline int get_qscale(MpegEncContext *s) |
1009 { | |
1253
5642ebadf1b5
small optimize mpeg12.c/get_qscale patch by (BERO <bero at geocities dot co dot jp>) and the return idea by arpi
michaelni
parents:
1220
diff
changeset
|
1010 int qscale = get_bits(&s->gb, 5); |
1421 | 1011 if (s->codec_id == CODEC_ID_MPEG2VIDEO) { |
54 | 1012 if (s->q_scale_type) { |
1253
5642ebadf1b5
small optimize mpeg12.c/get_qscale patch by (BERO <bero at geocities dot co dot jp>) and the return idea by arpi
michaelni
parents:
1220
diff
changeset
|
1013 return non_linear_qscale[qscale]; |
54 | 1014 } else { |
1253
5642ebadf1b5
small optimize mpeg12.c/get_qscale patch by (BERO <bero at geocities dot co dot jp>) and the return idea by arpi
michaelni
parents:
1220
diff
changeset
|
1015 return qscale << 1; |
54 | 1016 } |
1017 } | |
1018 return qscale; | |
1019 } | |
1020 | |
0 | 1021 /* motion type (for mpeg2) */ |
1022 #define MT_FIELD 1 | |
1023 #define MT_FRAME 2 | |
1024 #define MT_16X8 2 | |
1025 #define MT_DMV 3 | |
1026 | |
1027 static int mpeg_decode_mb(MpegEncContext *s, | |
1028 DCTELEM block[6][64]) | |
1029 { | |
751 | 1030 int i, j, k, cbp, val, mb_type, motion_type; |
0 | 1031 |
1032 dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y); | |
1033 | |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
947
diff
changeset
|
1034 assert(s->mb_skiped==0); |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
947
diff
changeset
|
1035 |
1160 | 1036 if (s->mb_skip_run-- != 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:
1164
diff
changeset
|
1037 if(s->pict_type == I_TYPE){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1038 av_log(s->avctx, AV_LOG_ERROR, "skiped MB in I frame at %d %d\n", s->mb_x, s->mb_y); |
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:
1164
diff
changeset
|
1039 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:
1164
diff
changeset
|
1040 } |
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:
1164
diff
changeset
|
1041 |
0 | 1042 /* skip mb */ |
1043 s->mb_intra = 0; | |
1044 for(i=0;i<6;i++) | |
1045 s->block_last_index[i] = -1; | |
1046 s->mv_type = MV_TYPE_16X16; | |
1047 if (s->pict_type == P_TYPE) { | |
1048 /* if P type, zero motion vector is implied */ | |
1049 s->mv_dir = MV_DIR_FORWARD; | |
1050 s->mv[0][0][0] = s->mv[0][0][1] = 0; | |
1051 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0; | |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1052 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0; |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
947
diff
changeset
|
1053 s->mb_skiped = 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:
1164
diff
changeset
|
1054 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; |
0 | 1055 } else { |
1056 /* if B type, reuse previous vectors and directions */ | |
1057 s->mv[0][0][0] = s->last_mv[0][0][0]; | |
1058 s->mv[0][0][1] = s->last_mv[0][0][1]; | |
1059 s->mv[1][0][0] = s->last_mv[1][0][0]; | |
1060 s->mv[1][0][1] = s->last_mv[1][0][1]; | |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
947
diff
changeset
|
1061 |
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:
1164
diff
changeset
|
1062 s->current_picture.mb_type[ 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:
1164
diff
changeset
|
1063 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP; |
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:
1164
diff
changeset
|
1064 // assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8)); |
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:
1164
diff
changeset
|
1065 |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
947
diff
changeset
|
1066 if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) |
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
947
diff
changeset
|
1067 s->mb_skiped = 1; |
0 | 1068 } |
930 | 1069 |
0 | 1070 return 0; |
1071 } | |
1072 | |
1073 switch(s->pict_type) { | |
1074 default: | |
1075 case I_TYPE: | |
21 | 1076 if (get_bits1(&s->gb) == 0) { |
1376 | 1077 if (get_bits1(&s->gb) == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1078 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y); |
0 | 1079 return -1; |
1376 | 1080 } |
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:
1164
diff
changeset
|
1081 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA; |
0 | 1082 } 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:
1164
diff
changeset
|
1083 mb_type = MB_TYPE_INTRA; |
0 | 1084 } |
1085 break; | |
1086 case P_TYPE: | |
545 | 1087 mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1); |
568 | 1088 if (mb_type < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1089 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y); |
0 | 1090 return -1; |
568 | 1091 } |
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:
1164
diff
changeset
|
1092 mb_type = ptype2mb_type[ mb_type ]; |
0 | 1093 break; |
1094 case B_TYPE: | |
545 | 1095 mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1); |
568 | 1096 if (mb_type < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1097 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y); |
0 | 1098 return -1; |
568 | 1099 } |
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:
1164
diff
changeset
|
1100 mb_type = btype2mb_type[ mb_type ]; |
0 | 1101 break; |
1102 } | |
1103 dprintf("mb_type=%x\n", 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:
1164
diff
changeset
|
1104 // motion_type = 0; /* avoid warning */ |
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:
1164
diff
changeset
|
1105 if (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:
1164
diff
changeset
|
1106 /* compute dct 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:
1164
diff
changeset
|
1107 if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var? |
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:
1164
diff
changeset
|
1108 !s->frame_pred_frame_dct) { |
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:
1164
diff
changeset
|
1109 s->interlaced_dct = 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:
1164
diff
changeset
|
1110 } |
0 | 1111 |
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:
1164
diff
changeset
|
1112 if (IS_QUANT(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:
1164
diff
changeset
|
1113 s->qscale = get_qscale(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:
1164
diff
changeset
|
1114 |
0 | 1115 if (s->concealment_motion_vectors) { |
1116 /* just parse them */ | |
1117 if (s->picture_structure != PICT_FRAME) | |
21 | 1118 skip_bits1(&s->gb); /* field select */ |
1323 | 1119 |
1120 s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] = | |
1121 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]); | |
1122 s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] = | |
1123 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]); | |
1124 | |
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:
1164
diff
changeset
|
1125 skip_bits1(&s->gb); /* marker */ |
1323 | 1126 }else |
1127 memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */ | |
0 | 1128 s->mb_intra = 1; |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1129 #ifdef HAVE_XVMC |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1130 //one 1 we memcpy blocks in xvmcvideo |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1131 if(s->avctx->xvmc_acceleration > 1){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1132 XVMC_pack_pblocks(s,-1);//inter are always full blocks |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1133 if(s->swap_uv){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1134 exchange_uv(s); |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1135 } |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1136 } |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1137 #endif |
0 | 1138 |
1421 | 1139 if (s->codec_id == CODEC_ID_MPEG2VIDEO) { |
0 | 1140 for(i=0;i<6;i++) { |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1141 if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0) |
711 | 1142 return -1; |
0 | 1143 } |
1144 } else { | |
1145 for(i=0;i<6;i++) { | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1146 if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 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:
1164
diff
changeset
|
1147 return -1; |
0 | 1148 } |
1149 } | |
1150 } 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:
1164
diff
changeset
|
1151 if (mb_type & MB_TYPE_ZERO_MV){ |
1655 | 1152 assert(mb_type & MB_TYPE_CBP); |
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:
1164
diff
changeset
|
1153 |
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:
1164
diff
changeset
|
1154 /* compute dct 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:
1164
diff
changeset
|
1155 if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var? |
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:
1164
diff
changeset
|
1156 !s->frame_pred_frame_dct) { |
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:
1164
diff
changeset
|
1157 s->interlaced_dct = 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:
1164
diff
changeset
|
1158 } |
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:
1164
diff
changeset
|
1159 |
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:
1164
diff
changeset
|
1160 if (IS_QUANT(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:
1164
diff
changeset
|
1161 s->qscale = get_qscale(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:
1164
diff
changeset
|
1162 |
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:
1164
diff
changeset
|
1163 s->mv_dir = MV_DIR_FORWARD; |
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:
1164
diff
changeset
|
1164 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:
1164
diff
changeset
|
1165 s->last_mv[0][0][0] = 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:
1164
diff
changeset
|
1166 s->last_mv[0][0][1] = 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:
1164
diff
changeset
|
1167 s->last_mv[0][1][0] = 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:
1164
diff
changeset
|
1168 s->last_mv[0][1][1] = 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:
1164
diff
changeset
|
1169 s->mv[0][0][0] = 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:
1164
diff
changeset
|
1170 s->mv[0][0][1] = 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:
1164
diff
changeset
|
1171 }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:
1164
diff
changeset
|
1172 assert(mb_type & 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:
1164
diff
changeset
|
1173 //FIXME decide if MBs in field pictures are 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:
1164
diff
changeset
|
1174 /* get additionnal motion vector 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:
1164
diff
changeset
|
1175 if (s->frame_pred_frame_dct) |
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:
1164
diff
changeset
|
1176 motion_type = MT_FRAME; |
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:
1164
diff
changeset
|
1177 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:
1164
diff
changeset
|
1178 motion_type = get_bits(&s->gb, 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:
1164
diff
changeset
|
1179 } |
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:
1164
diff
changeset
|
1180 |
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:
1164
diff
changeset
|
1181 /* compute dct 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:
1164
diff
changeset
|
1182 if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var? |
1655 | 1183 !s->frame_pred_frame_dct && HAS_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:
1164
diff
changeset
|
1184 s->interlaced_dct = 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:
1164
diff
changeset
|
1185 } |
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:
1164
diff
changeset
|
1186 |
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:
1164
diff
changeset
|
1187 if (IS_QUANT(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:
1164
diff
changeset
|
1188 s->qscale = get_qscale(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:
1164
diff
changeset
|
1189 |
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:
1164
diff
changeset
|
1190 /* motion vectors */ |
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:
1164
diff
changeset
|
1191 s->mv_dir = 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:
1164
diff
changeset
|
1192 for(i=0;i<2;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:
1164
diff
changeset
|
1193 if (USES_LIST(mb_type, 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:
1164
diff
changeset
|
1194 s->mv_dir |= (MV_DIR_FORWARD >> 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:
1164
diff
changeset
|
1195 dprintf("motion_type=%d\n", motion_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:
1164
diff
changeset
|
1196 switch(motion_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:
1164
diff
changeset
|
1197 case MT_FRAME: /* or MT_16X8 */ |
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:
1164
diff
changeset
|
1198 if (s->picture_structure == PICT_FRAME) { |
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:
1164
diff
changeset
|
1199 /* MT_FRAME */ |
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:
1164
diff
changeset
|
1200 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:
1164
diff
changeset
|
1201 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:
1164
diff
changeset
|
1202 s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][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:
1164
diff
changeset
|
1203 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][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:
1164
diff
changeset
|
1204 s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][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:
1164
diff
changeset
|
1205 mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][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:
1164
diff
changeset
|
1206 /* full_pel: only for mpeg1 */ |
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:
1164
diff
changeset
|
1207 if (s->full_pel[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:
1164
diff
changeset
|
1208 s->mv[i][0][0] <<= 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:
1164
diff
changeset
|
1209 s->mv[i][0][1] <<= 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:
1164
diff
changeset
|
1210 } |
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:
1164
diff
changeset
|
1211 } 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:
1164
diff
changeset
|
1212 /* MT_16X8 */ |
1673 | 1213 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; |
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:
1164
diff
changeset
|
1214 s->mv_type = MV_TYPE_16X8; |
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:
1164
diff
changeset
|
1215 for(j=0;j<2;j++) { |
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:
1164
diff
changeset
|
1216 s->field_select[i][j] = 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:
1164
diff
changeset
|
1217 for(k=0;k<2;k++) { |
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:
1164
diff
changeset
|
1218 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], |
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:
1164
diff
changeset
|
1219 s->last_mv[i][j][k]); |
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:
1164
diff
changeset
|
1220 s->last_mv[i][j][k] = val; |
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:
1164
diff
changeset
|
1221 s->mv[i][j][k] = val; |
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:
1164
diff
changeset
|
1222 } |
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:
1164
diff
changeset
|
1223 } |
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:
1164
diff
changeset
|
1224 } |
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:
1164
diff
changeset
|
1225 break; |
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:
1164
diff
changeset
|
1226 case MT_FIELD: |
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:
1164
diff
changeset
|
1227 s->mv_type = MV_TYPE_FIELD; |
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:
1164
diff
changeset
|
1228 if (s->picture_structure == PICT_FRAME) { |
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:
1164
diff
changeset
|
1229 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:
1164
diff
changeset
|
1230 for(j=0;j<2;j++) { |
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:
1164
diff
changeset
|
1231 s->field_select[i][j] = 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:
1164
diff
changeset
|
1232 val = mpeg_decode_motion(s, s->mpeg_f_code[i][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:
1164
diff
changeset
|
1233 s->last_mv[i][j][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:
1164
diff
changeset
|
1234 s->last_mv[i][j][0] = val; |
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:
1164
diff
changeset
|
1235 s->mv[i][j][0] = val; |
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:
1164
diff
changeset
|
1236 dprintf("fmx=%d\n", val); |
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:
1164
diff
changeset
|
1237 val = mpeg_decode_motion(s, s->mpeg_f_code[i][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:
1164
diff
changeset
|
1238 s->last_mv[i][j][1] >> 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:
1164
diff
changeset
|
1239 s->last_mv[i][j][1] = val << 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:
1164
diff
changeset
|
1240 s->mv[i][j][1] = val; |
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:
1164
diff
changeset
|
1241 dprintf("fmy=%d\n", val); |
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:
1164
diff
changeset
|
1242 } |
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:
1164
diff
changeset
|
1243 } else { |
1673 | 1244 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; |
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:
1164
diff
changeset
|
1245 s->field_select[i][0] = 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:
1164
diff
changeset
|
1246 for(k=0;k<2;k++) { |
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:
1164
diff
changeset
|
1247 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], |
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:
1164
diff
changeset
|
1248 s->last_mv[i][0][k]); |
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:
1164
diff
changeset
|
1249 s->last_mv[i][0][k] = val; |
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:
1164
diff
changeset
|
1250 s->last_mv[i][1][k] = val; |
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:
1164
diff
changeset
|
1251 s->mv[i][0][k] = val; |
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:
1164
diff
changeset
|
1252 } |
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:
1164
diff
changeset
|
1253 } |
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:
1164
diff
changeset
|
1254 break; |
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:
1164
diff
changeset
|
1255 case MT_DMV: |
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:
1164
diff
changeset
|
1256 { |
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:
1164
diff
changeset
|
1257 int dmx, dmy, mx, my, m; |
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:
1164
diff
changeset
|
1258 |
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:
1164
diff
changeset
|
1259 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][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:
1164
diff
changeset
|
1260 s->last_mv[i][0][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:
1164
diff
changeset
|
1261 s->last_mv[i][0][0] = 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:
1164
diff
changeset
|
1262 s->last_mv[i][1][0] = 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:
1164
diff
changeset
|
1263 dmx = get_dmv(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:
1164
diff
changeset
|
1264 my = mpeg_decode_motion(s, s->mpeg_f_code[i][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:
1164
diff
changeset
|
1265 s->last_mv[i][0][1] >> 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:
1164
diff
changeset
|
1266 dmy = get_dmv(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:
1164
diff
changeset
|
1267 s->mv_type = MV_TYPE_DMV; |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1268 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1269 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1270 s->last_mv[i][0][1] = my<<1; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1271 s->last_mv[i][1][1] = my<<1; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1272 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1273 s->mv[i][0][0] = mx; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1274 s->mv[i][0][1] = my; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1275 s->mv[i][1][0] = mx;//not used |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1276 s->mv[i][1][1] = my;//not used |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1277 |
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:
1164
diff
changeset
|
1278 if (s->picture_structure == PICT_FRAME) { |
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:
1164
diff
changeset
|
1279 mb_type |= MB_TYPE_16x16 | 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:
1164
diff
changeset
|
1280 |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1281 //m = 1 + 2 * s->top_field_first; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1282 m = s->top_field_first ? 1 : 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:
1164
diff
changeset
|
1283 |
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:
1164
diff
changeset
|
1284 /* top -> top pred */ |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1285 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1286 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 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:
1164
diff
changeset
|
1287 m = 4 - m; |
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:
1164
diff
changeset
|
1288 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx; |
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:
1164
diff
changeset
|
1289 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 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:
1164
diff
changeset
|
1290 } 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:
1164
diff
changeset
|
1291 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:
1164
diff
changeset
|
1292 |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1293 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1294 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1295 if(s->picture_structure == PICT_TOP_FIELD) |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1296 s->mv[i][2][1]--; |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1297 else |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
1298 s->mv[i][2][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:
1164
diff
changeset
|
1299 } |
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:
1164
diff
changeset
|
1300 } |
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:
1164
diff
changeset
|
1301 break; |
1673 | 1302 default: |
1303 av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y); | |
1304 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:
1164
diff
changeset
|
1305 } |
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:
1164
diff
changeset
|
1306 } |
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:
1164
diff
changeset
|
1307 } |
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:
1164
diff
changeset
|
1308 } |
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:
1164
diff
changeset
|
1309 |
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:
1164
diff
changeset
|
1310 s->mb_intra = 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:
1164
diff
changeset
|
1311 |
1655 | 1312 if (HAS_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:
1164
diff
changeset
|
1313 cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 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:
1164
diff
changeset
|
1314 if (cbp < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1315 av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y); |
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:
1164
diff
changeset
|
1316 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:
1164
diff
changeset
|
1317 } |
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:
1164
diff
changeset
|
1318 cbp++; |
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:
1164
diff
changeset
|
1319 |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1320 #ifdef HAVE_XVMC |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1321 //on 1 we memcpy blocks in xvmcvideo |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1322 if(s->avctx->xvmc_acceleration > 1){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1323 XVMC_pack_pblocks(s,cbp); |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1324 if(s->swap_uv){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1325 exchange_uv(s); |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1326 } |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1327 } |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1328 #endif |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1329 |
1421 | 1330 if (s->codec_id == CODEC_ID_MPEG2VIDEO) { |
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:
1164
diff
changeset
|
1331 for(i=0;i<6;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:
1164
diff
changeset
|
1332 if (cbp & 32) { |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1333 if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 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:
1164
diff
changeset
|
1334 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:
1164
diff
changeset
|
1335 } 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:
1164
diff
changeset
|
1336 s->block_last_index[i] = -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:
1164
diff
changeset
|
1337 } |
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:
1164
diff
changeset
|
1338 cbp+=cbp; |
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:
1164
diff
changeset
|
1339 } |
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:
1164
diff
changeset
|
1340 } 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:
1164
diff
changeset
|
1341 for(i=0;i<6;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:
1164
diff
changeset
|
1342 if (cbp & 32) { |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1343 if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 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:
1164
diff
changeset
|
1344 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:
1164
diff
changeset
|
1345 } 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:
1164
diff
changeset
|
1346 s->block_last_index[i] = -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:
1164
diff
changeset
|
1347 } |
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:
1164
diff
changeset
|
1348 cbp+=cbp; |
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:
1164
diff
changeset
|
1349 } |
711 | 1350 } |
1351 }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:
1164
diff
changeset
|
1352 for(i=0;i<6;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:
1164
diff
changeset
|
1353 s->block_last_index[i] = -1; |
0 | 1354 } |
1355 } | |
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:
1164
diff
changeset
|
1356 |
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:
1164
diff
changeset
|
1357 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= 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:
1164
diff
changeset
|
1358 |
0 | 1359 return 0; |
1360 } | |
1361 | |
1362 /* as h263, but only 17 codes */ | |
1363 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred) | |
1364 { | |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
1365 int code, sign, val, l, shift; |
0 | 1366 |
545 | 1367 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 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:
1164
diff
changeset
|
1368 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:
1164
diff
changeset
|
1369 return 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:
1164
diff
changeset
|
1370 } |
0 | 1371 if (code < 0) { |
1372 return 0xffff; | |
1373 } | |
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:
1164
diff
changeset
|
1374 |
21 | 1375 sign = get_bits1(&s->gb); |
0 | 1376 shift = fcode - 1; |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
1377 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
1378 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
1379 val = (val - 1) << shift; |
0 | 1380 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
|
1381 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
1382 } |
0 | 1383 if (sign) |
1384 val = -val; | |
1385 val += pred; | |
1386 | |
1387 /* modulo decoding */ | |
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:
1164
diff
changeset
|
1388 l = 1 << (shift+4); |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
1389 val = ((val + l)&(l*2-1)) - l; |
0 | 1390 return val; |
1391 } | |
1392 | |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
1393 static inline int decode_dc(GetBitContext *gb, int component) |
0 | 1394 { |
1395 int code, diff; | |
1396 | |
1397 if (component == 0) { | |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
1398 code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2); |
0 | 1399 } else { |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
1400 code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2); |
0 | 1401 } |
568 | 1402 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1403 av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n"); |
0 | 1404 return 0xffff; |
568 | 1405 } |
0 | 1406 if (code == 0) { |
1407 diff = 0; | |
1408 } else { | |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
1409 diff = get_xbits(gb, code); |
0 | 1410 } |
1411 return diff; | |
1412 } | |
1413 | |
711 | 1414 static inline int mpeg1_decode_block_intra(MpegEncContext *s, |
0 | 1415 DCTELEM *block, |
1416 int n) | |
1417 { | |
1418 int level, dc, diff, i, j, run; | |
711 | 1419 int component; |
0 | 1420 RLTable *rl = &rl_mpeg1; |
1064 | 1421 uint8_t * const scantable= s->intra_scantable.permutated; |
1422 const uint16_t *quant_matrix= s->intra_matrix; | |
711 | 1423 const int qscale= s->qscale; |
0 | 1424 |
711 | 1425 /* DC coef */ |
1426 component = (n <= 3 ? 0 : n - 4 + 1); | |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
1427 diff = decode_dc(&s->gb, component); |
711 | 1428 if (diff >= 0xffff) |
1429 return -1; | |
1430 dc = s->last_dc[component]; | |
1431 dc += diff; | |
1432 s->last_dc[component] = dc; | |
1433 block[0] = dc<<3; | |
1434 dprintf("dc=%d diff=%d\n", dc, diff); | |
1435 i = 0; | |
1436 { | |
1437 OPEN_READER(re, &s->gb); | |
1438 /* now quantify & encode AC coefs */ | |
1439 for(;;) { | |
1440 UPDATE_CACHE(re, &s->gb); | |
1441 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2); | |
1442 | |
1443 if(level == 127){ | |
1444 break; | |
1445 } else if(level != 0) { | |
1446 i += run; | |
1447 j = scantable[i]; | |
1448 level= (level*qscale*quant_matrix[j])>>3; | |
1449 level= (level-1)|1; | |
1450 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1451 LAST_SKIP_BITS(re, &s->gb, 1); | |
1452 } else { | |
1453 /* escape */ | |
1454 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
1455 UPDATE_CACHE(re, &s->gb); | |
1456 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8); | |
1457 if (level == -128) { | |
1458 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8); | |
1459 } else if (level == 0) { | |
1460 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8); | |
1461 } | |
1462 i += run; | |
1463 j = scantable[i]; | |
1464 if(level<0){ | |
1465 level= -level; | |
1466 level= (level*qscale*quant_matrix[j])>>3; | |
1467 level= (level-1)|1; | |
1468 level= -level; | |
1469 }else{ | |
1470 level= (level*qscale*quant_matrix[j])>>3; | |
1471 level= (level-1)|1; | |
1472 } | |
1473 } | |
1474 if (i > 63){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1475 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
711 | 1476 return -1; |
1477 } | |
1478 | |
1479 block[j] = level; | |
1480 } | |
1481 CLOSE_READER(re, &s->gb); | |
1482 } | |
1483 s->block_last_index[n] = i; | |
1484 return 0; | |
1485 } | |
1486 | |
1487 static inline int mpeg1_decode_block_inter(MpegEncContext *s, | |
1488 DCTELEM *block, | |
1489 int n) | |
1490 { | |
1491 int level, i, j, run; | |
1492 RLTable *rl = &rl_mpeg1; | |
1064 | 1493 uint8_t * const scantable= s->intra_scantable.permutated; |
1494 const uint16_t *quant_matrix= s->inter_matrix; | |
711 | 1495 const int qscale= s->qscale; |
1496 | |
1497 { | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1498 int v; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1499 OPEN_READER(re, &s->gb); |
711 | 1500 i = -1; |
0 | 1501 /* special case for the first coef. no need to add a second vlc table */ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1502 UPDATE_CACHE(re, &s->gb); |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1503 v= SHOW_UBITS(re, &s->gb, 2); |
0 | 1504 if (v & 2) { |
714 | 1505 LAST_SKIP_BITS(re, &s->gb, 2); |
711 | 1506 level= (3*qscale*quant_matrix[0])>>4; |
1507 level= (level-1)|1; | |
1508 if(v&1) | |
1509 level= -level; | |
714 | 1510 block[0] = level; |
711 | 1511 i++; |
0 | 1512 } |
714 | 1513 |
711 | 1514 /* now quantify & encode AC coefs */ |
1515 for(;;) { | |
1516 UPDATE_CACHE(re, &s->gb); | |
1517 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2); | |
1518 | |
1519 if(level == 127){ | |
1520 break; | |
1521 } else if(level != 0) { | |
1522 i += run; | |
1523 j = scantable[i]; | |
1524 level= ((level*2+1)*qscale*quant_matrix[j])>>4; | |
1525 level= (level-1)|1; | |
1526 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1527 LAST_SKIP_BITS(re, &s->gb, 1); | |
1528 } else { | |
1529 /* escape */ | |
1530 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
1531 UPDATE_CACHE(re, &s->gb); | |
1532 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8); | |
1533 if (level == -128) { | |
1534 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8); | |
1535 } else if (level == 0) { | |
1536 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8); | |
1537 } | |
1538 i += run; | |
1539 j = scantable[i]; | |
1540 if(level<0){ | |
1541 level= -level; | |
1542 level= ((level*2+1)*qscale*quant_matrix[j])>>4; | |
1543 level= (level-1)|1; | |
1544 level= -level; | |
1545 }else{ | |
1546 level= ((level*2+1)*qscale*quant_matrix[j])>>4; | |
1547 level= (level-1)|1; | |
1548 } | |
1549 } | |
1550 if (i > 63){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1551 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
711 | 1552 return -1; |
1553 } | |
0 | 1554 |
711 | 1555 block[j] = level; |
0 | 1556 } |
711 | 1557 CLOSE_READER(re, &s->gb); |
0 | 1558 } |
711 | 1559 s->block_last_index[n] = i; |
0 | 1560 return 0; |
1561 } | |
1562 | |
1563 /* Also does unquantization here, since I will never support mpeg2 | |
1564 encoding */ | |
714 | 1565 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, |
1566 DCTELEM *block, | |
1567 int n) | |
0 | 1568 { |
1569 int level, i, j, run; | |
1570 RLTable *rl = &rl_mpeg1; | |
1064 | 1571 uint8_t * const scantable= s->intra_scantable.permutated; |
1572 const uint16_t *quant_matrix; | |
714 | 1573 const int qscale= s->qscale; |
0 | 1574 int mismatch; |
1575 | |
1576 mismatch = 1; | |
1577 | |
1578 { | |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1579 int v; |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1580 OPEN_READER(re, &s->gb); |
714 | 1581 i = -1; |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1582 if (n < 4) |
714 | 1583 quant_matrix = s->inter_matrix; |
0 | 1584 else |
714 | 1585 quant_matrix = s->chroma_inter_matrix; |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1586 |
0 | 1587 /* special case for the first coef. no need to add a second vlc table */ |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1588 UPDATE_CACHE(re, &s->gb); |
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1589 v= SHOW_UBITS(re, &s->gb, 2); |
0 | 1590 if (v & 2) { |
714 | 1591 LAST_SKIP_BITS(re, &s->gb, 2); |
1592 level= (3*qscale*quant_matrix[0])>>5; | |
1593 if(v&1) | |
1594 level= -level; | |
1595 block[0] = level; | |
1596 mismatch ^= level; | |
1597 i++; | |
1598 } | |
1599 | |
1600 /* now quantify & encode AC coefs */ | |
1601 for(;;) { | |
1602 UPDATE_CACHE(re, &s->gb); | |
1603 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2); | |
1604 | |
1605 if(level == 127){ | |
1606 break; | |
1607 } else if(level != 0) { | |
1608 i += run; | |
1609 j = scantable[i]; | |
1610 level= ((level*2+1)*qscale*quant_matrix[j])>>5; | |
1611 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1612 LAST_SKIP_BITS(re, &s->gb, 1); | |
1613 } else { | |
1614 /* escape */ | |
1615 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
1616 UPDATE_CACHE(re, &s->gb); | |
1617 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); | |
1618 | |
1619 i += run; | |
1620 j = scantable[i]; | |
1621 if(level<0){ | |
1622 level= ((-level*2+1)*qscale*quant_matrix[j])>>5; | |
1623 level= -level; | |
1624 }else{ | |
1625 level= ((level*2+1)*qscale*quant_matrix[j])>>5; | |
1626 } | |
1627 } | |
1628 if (i > 63){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1629 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
714 | 1630 return -1; |
1631 } | |
1632 | |
1633 mismatch ^= level; | |
1634 block[j] = level; | |
0 | 1635 } |
520
19a5e2a81e1a
new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents:
498
diff
changeset
|
1636 CLOSE_READER(re, &s->gb); |
0 | 1637 } |
1638 block[63] ^= (mismatch & 1); | |
714 | 1639 |
0 | 1640 s->block_last_index[n] = i; |
1641 return 0; | |
1642 } | |
1643 | |
714 | 1644 static inline int mpeg2_decode_block_intra(MpegEncContext *s, |
1645 DCTELEM *block, | |
1646 int n) | |
0 | 1647 { |
1648 int level, dc, diff, i, j, run; | |
714 | 1649 int component; |
0 | 1650 RLTable *rl; |
1064 | 1651 uint8_t * const scantable= s->intra_scantable.permutated; |
1652 const uint16_t *quant_matrix; | |
714 | 1653 const int qscale= s->qscale; |
0 | 1654 int mismatch; |
1655 | |
1656 /* DC coef */ | |
714 | 1657 if (n < 4){ |
1658 quant_matrix = s->intra_matrix; | |
1659 component = 0; | |
1660 }else{ | |
1661 quant_matrix = s->chroma_intra_matrix; | |
1662 component = n - 3; | |
1663 } | |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
1664 diff = decode_dc(&s->gb, component); |
0 | 1665 if (diff >= 0xffff) |
1666 return -1; | |
1667 dc = s->last_dc[component]; | |
1668 dc += diff; | |
1669 s->last_dc[component] = dc; | |
1670 block[0] = dc << (3 - s->intra_dc_precision); | |
1671 dprintf("dc=%d\n", block[0]); | |
58
0e0a24def67a
fixed last zero mv for field - fixed mismatch handling for intra coefs
glantau
parents:
54
diff
changeset
|
1672 mismatch = block[0] ^ 1; |
714 | 1673 i = 0; |
0 | 1674 if (s->intra_vlc_format) |
1675 rl = &rl_mpeg2; | |
1676 else | |
1677 rl = &rl_mpeg1; | |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1678 |
714 | 1679 { |
1680 OPEN_READER(re, &s->gb); | |
1681 /* now quantify & encode AC coefs */ | |
1682 for(;;) { | |
1683 UPDATE_CACHE(re, &s->gb); | |
1684 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2); | |
1685 | |
1686 if(level == 127){ | |
1687 break; | |
1688 } else if(level != 0) { | |
1689 i += run; | |
1690 j = scantable[i]; | |
1691 level= (level*qscale*quant_matrix[j])>>4; | |
1692 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1693 LAST_SKIP_BITS(re, &s->gb, 1); | |
1694 } else { | |
1695 /* escape */ | |
1696 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
1697 UPDATE_CACHE(re, &s->gb); | |
1698 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); | |
1699 i += run; | |
1700 j = scantable[i]; | |
1701 if(level<0){ | |
1702 level= (-level*qscale*quant_matrix[j])>>4; | |
1703 level= -level; | |
1704 }else{ | |
1705 level= (level*qscale*quant_matrix[j])>>4; | |
1706 } | |
1707 } | |
1708 if (i > 63){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1709 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
714 | 1710 return -1; |
1711 } | |
1712 | |
1713 mismatch^= level; | |
1714 block[j] = level; | |
568 | 1715 } |
714 | 1716 CLOSE_READER(re, &s->gb); |
0 | 1717 } |
714 | 1718 block[63]^= mismatch&1; |
1719 | |
0 | 1720 s->block_last_index[n] = i; |
1721 return 0; | |
1722 } | |
1723 | |
1724 typedef struct Mpeg1Context { | |
1725 MpegEncContext mpeg_enc_ctx; | |
1726 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ | |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
1727 int repeat_field; /* true if we must repeat the field */ |
1546 | 1728 AVPanScan pan_scan; /** some temporary storage for the panscan */ |
0 | 1729 } Mpeg1Context; |
1730 | |
1731 static int mpeg_decode_init(AVCodecContext *avctx) | |
1732 { | |
1733 Mpeg1Context *s = avctx->priv_data; | |
498 | 1734 |
558 | 1735 s->mpeg_enc_ctx.flags= avctx->flags; |
498 | 1736 common_init(&s->mpeg_enc_ctx); |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
1737 init_vlcs(); |
0 | 1738 |
1739 s->mpeg_enc_ctx_allocated = 0; | |
1740 s->mpeg_enc_ctx.picture_number = 0; | |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
1741 s->repeat_field = 0; |
344 | 1742 s->mpeg_enc_ctx.codec_id= avctx->codec->id; |
0 | 1743 return 0; |
1744 } | |
1745 | |
1746 /* return the 8 bit start code value and update the search | |
1747 state. Return -1 if no start code found */ | |
1211 | 1748 static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end) |
0 | 1749 { |
1064 | 1750 uint8_t *buf_ptr; |
1211 | 1751 unsigned int state=0xFFFFFFFF, v; |
0 | 1752 int val; |
1753 | |
1754 buf_ptr = *pbuf_ptr; | |
1755 while (buf_ptr < buf_end) { | |
1756 v = *buf_ptr++; | |
1757 if (state == 0x000001) { | |
1758 state = ((state << 8) | v) & 0xffffff; | |
1759 val = state; | |
1760 goto found; | |
1761 } | |
1762 state = ((state << 8) | v) & 0xffffff; | |
1763 } | |
1764 val = -1; | |
1765 found: | |
1766 *pbuf_ptr = buf_ptr; | |
1767 return val; | |
1768 } | |
1769 | |
1770 static int mpeg1_decode_picture(AVCodecContext *avctx, | |
1064 | 1771 uint8_t *buf, int buf_size) |
0 | 1772 { |
1773 Mpeg1Context *s1 = avctx->priv_data; | |
1774 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
1697 | 1775 int ref, f_code, vbv_delay; |
0 | 1776 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1021
diff
changeset
|
1777 init_get_bits(&s->gb, buf, buf_size*8); |
0 | 1778 |
1779 ref = get_bits(&s->gb, 10); /* temporal ref */ | |
1780 s->pict_type = get_bits(&s->gb, 3); | |
45
933cc4acab5c
fixed mpeg1 last block bug (mb stuffing code was not included in vlc table...)
glantau
parents:
38
diff
changeset
|
1781 dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number); |
872 | 1782 |
1697 | 1783 vbv_delay= get_bits(&s->gb, 16); |
0 | 1784 if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) { |
21 | 1785 s->full_pel[0] = get_bits1(&s->gb); |
0 | 1786 f_code = get_bits(&s->gb, 3); |
1787 if (f_code == 0) | |
1788 return -1; | |
1789 s->mpeg_f_code[0][0] = f_code; | |
1790 s->mpeg_f_code[0][1] = f_code; | |
1791 } | |
1792 if (s->pict_type == B_TYPE) { | |
21 | 1793 s->full_pel[1] = get_bits1(&s->gb); |
0 | 1794 f_code = get_bits(&s->gb, 3); |
1795 if (f_code == 0) | |
1796 return -1; | |
1797 s->mpeg_f_code[1][0] = f_code; | |
1798 s->mpeg_f_code[1][1] = f_code; | |
1799 } | |
903 | 1800 s->current_picture.pict_type= s->pict_type; |
1801 s->current_picture.key_frame= s->pict_type == I_TYPE; | |
911 | 1802 |
0 | 1803 s->y_dc_scale = 8; |
1804 s->c_dc_scale = 8; | |
1805 s->first_slice = 1; | |
1806 return 0; | |
1807 } | |
1808 | |
1809 static void mpeg_decode_sequence_extension(MpegEncContext *s) | |
1810 { | |
1811 int horiz_size_ext, vert_size_ext; | |
917 | 1812 int bit_rate_ext, vbv_buf_ext; |
0 | 1813 int frame_rate_ext_n, frame_rate_ext_d; |
1421 | 1814 int level, profile; |
0 | 1815 |
1421 | 1816 skip_bits(&s->gb, 1); /* profil and level esc*/ |
1817 profile= get_bits(&s->gb, 3); | |
1818 level= get_bits(&s->gb, 4); | |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
1819 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */ |
21 | 1820 skip_bits(&s->gb, 2); /* chroma_format */ |
0 | 1821 horiz_size_ext = get_bits(&s->gb, 2); |
1822 vert_size_ext = get_bits(&s->gb, 2); | |
1823 s->width |= (horiz_size_ext << 12); | |
1824 s->height |= (vert_size_ext << 12); | |
1825 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */ | |
1826 s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400; | |
21 | 1827 skip_bits1(&s->gb); /* marker */ |
0 | 1828 vbv_buf_ext = get_bits(&s->gb, 8); |
1346 | 1829 |
917 | 1830 s->low_delay = get_bits1(&s->gb); |
1346 | 1831 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1; |
1832 | |
0 | 1833 frame_rate_ext_n = get_bits(&s->gb, 2); |
1834 frame_rate_ext_d = get_bits(&s->gb, 5); | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
1835 av_reduce( |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
1836 &s->avctx->frame_rate, |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
1837 &s->avctx->frame_rate_base, |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
1838 frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1), |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
1839 MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1), |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
1840 1<<30); |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
1841 |
0 | 1842 dprintf("sequence extension\n"); |
1421 | 1843 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO; |
401
e20655449d4a
mpeg1/2 identifier - fixed frame rate for some bad mpeg1 streams
glantau
parents:
391
diff
changeset
|
1844 s->avctx->sub_id = 2; /* indicates mpeg2 found */ |
917 | 1845 |
1548 | 1846 if(s->aspect_ratio_info <= 1) |
1847 s->avctx->sample_aspect_ratio= mpeg2_aspect[s->aspect_ratio_info]; | |
1848 else{ | |
1849 s->avctx->sample_aspect_ratio= | |
1850 av_div_q( | |
1851 mpeg2_aspect[s->aspect_ratio_info], | |
1852 (AVRational){s->width, s->height} | |
1853 ); | |
1854 } | |
1421 | 1855 |
1856 if(s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1857 av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d \n", profile, level); |
0 | 1858 } |
1859 | |
1546 | 1860 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1) |
1861 { | |
1862 MpegEncContext *s= &s1->mpeg_enc_ctx; | |
1863 int color_description, w, h; | |
1864 | |
1865 skip_bits(&s->gb, 3); /* video format */ | |
1866 color_description= get_bits1(&s->gb); | |
1867 if(color_description){ | |
1868 skip_bits(&s->gb, 8); /* color primaries */ | |
1869 skip_bits(&s->gb, 8); /* transfer_characteristics */ | |
1870 skip_bits(&s->gb, 8); /* matrix_coefficients */ | |
1871 } | |
1872 w= get_bits(&s->gb, 14); | |
1873 skip_bits(&s->gb, 1); //marker | |
1874 h= get_bits(&s->gb, 14); | |
1875 skip_bits(&s->gb, 1); //marker | |
1876 | |
1877 s1->pan_scan.width= 16*w; | |
1878 s1->pan_scan.height=16*h; | |
1879 | |
1548 | 1880 if(s->aspect_ratio_info > 1) |
1881 s->avctx->sample_aspect_ratio= | |
1882 av_div_q( | |
1883 mpeg2_aspect[s->aspect_ratio_info], | |
1884 (AVRational){w, h} | |
1885 ); | |
1546 | 1886 |
1887 if(s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1888 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h); |
1546 | 1889 } |
1890 | |
1891 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1) | |
1892 { | |
1893 MpegEncContext *s= &s1->mpeg_enc_ctx; | |
1894 int i; | |
1895 | |
1896 for(i=0; i<1; i++){ //FIXME count | |
1897 s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16); | |
1898 skip_bits(&s->gb, 1); //marker | |
1899 s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16); | |
1900 skip_bits(&s->gb, 1); //marker | |
1901 } | |
1902 | |
1903 if(s->avctx->debug & FF_DEBUG_PICT_INFO) | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1904 av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n", |
1546 | 1905 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1], |
1906 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1], | |
1907 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1] | |
1908 ); | |
1909 } | |
1910 | |
0 | 1911 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s) |
1912 { | |
38
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
1913 int i, v, j; |
0 | 1914 |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1915 dprintf("matrix extension\n"); |
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1916 |
21 | 1917 if (get_bits1(&s->gb)) { |
0 | 1918 for(i=0;i<64;i++) { |
1919 v = get_bits(&s->gb, 8); | |
1092 | 1920 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
38
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
1921 s->intra_matrix[j] = v; |
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
1922 s->chroma_intra_matrix[j] = v; |
0 | 1923 } |
1924 } | |
21 | 1925 if (get_bits1(&s->gb)) { |
0 | 1926 for(i=0;i<64;i++) { |
1927 v = get_bits(&s->gb, 8); | |
1092 | 1928 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
344 | 1929 s->inter_matrix[j] = v; |
1930 s->chroma_inter_matrix[j] = v; | |
0 | 1931 } |
1932 } | |
21 | 1933 if (get_bits1(&s->gb)) { |
0 | 1934 for(i=0;i<64;i++) { |
1935 v = get_bits(&s->gb, 8); | |
1092 | 1936 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
38
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
1937 s->chroma_intra_matrix[j] = v; |
0 | 1938 } |
1939 } | |
21 | 1940 if (get_bits1(&s->gb)) { |
0 | 1941 for(i=0;i<64;i++) { |
1942 v = get_bits(&s->gb, 8); | |
1092 | 1943 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
344 | 1944 s->chroma_inter_matrix[j] = v; |
0 | 1945 } |
1946 } | |
1947 } | |
1948 | |
1949 static void mpeg_decode_picture_coding_extension(MpegEncContext *s) | |
1950 { | |
1951 s->full_pel[0] = s->full_pel[1] = 0; | |
1952 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4); | |
1953 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4); | |
1954 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4); | |
1955 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4); | |
1956 s->intra_dc_precision = get_bits(&s->gb, 2); | |
1957 s->picture_structure = get_bits(&s->gb, 2); | |
21 | 1958 s->top_field_first = get_bits1(&s->gb); |
1959 s->frame_pred_frame_dct = get_bits1(&s->gb); | |
1960 s->concealment_motion_vectors = get_bits1(&s->gb); | |
1961 s->q_scale_type = get_bits1(&s->gb); | |
1962 s->intra_vlc_format = get_bits1(&s->gb); | |
1963 s->alternate_scan = get_bits1(&s->gb); | |
1964 s->repeat_first_field = get_bits1(&s->gb); | |
1965 s->chroma_420_type = get_bits1(&s->gb); | |
1966 s->progressive_frame = get_bits1(&s->gb); | |
1708 | 1967 |
1096
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
1968 if(s->picture_structure == PICT_FRAME) |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
1969 s->first_field=0; |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
1970 else{ |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
1971 s->first_field ^= 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:
1164
diff
changeset
|
1972 memset(s->mbskip_table, 0, s->mb_stride*s->mb_height); |
1096
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
1973 } |
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
1974 |
715
8b3ccabfce4a
move scantable init from block-decode to header parser
michaelni
parents:
714
diff
changeset
|
1975 if(s->alternate_scan){ |
1273 | 1976 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
1977 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
715
8b3ccabfce4a
move scantable init from block-decode to header parser
michaelni
parents:
714
diff
changeset
|
1978 }else{ |
1273 | 1979 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
1980 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
715
8b3ccabfce4a
move scantable init from block-decode to header parser
michaelni
parents:
714
diff
changeset
|
1981 } |
8b3ccabfce4a
move scantable init from block-decode to header parser
michaelni
parents:
714
diff
changeset
|
1982 |
0 | 1983 /* composite display not parsed */ |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
1984 dprintf("intra_dc_precision=%d\n", s->intra_dc_precision); |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1985 dprintf("picture_structure=%d\n", s->picture_structure); |
383
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
1986 dprintf("top field first=%d\n", s->top_field_first); |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
1987 dprintf("repeat first field=%d\n", s->repeat_first_field); |
0 | 1988 dprintf("conceal=%d\n", s->concealment_motion_vectors); |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1989 dprintf("intra_vlc_format=%d\n", s->intra_vlc_format); |
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1990 dprintf("alternate_scan=%d\n", s->alternate_scan); |
0 | 1991 dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct); |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
1992 dprintf("progressive_frame=%d\n", s->progressive_frame); |
0 | 1993 } |
1994 | |
1995 static void mpeg_decode_extension(AVCodecContext *avctx, | |
1064 | 1996 uint8_t *buf, int buf_size) |
0 | 1997 { |
1998 Mpeg1Context *s1 = avctx->priv_data; | |
1999 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
2000 int ext_type; | |
2001 | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1021
diff
changeset
|
2002 init_get_bits(&s->gb, buf, buf_size*8); |
0 | 2003 |
2004 ext_type = get_bits(&s->gb, 4); | |
2005 switch(ext_type) { | |
2006 case 0x1: | |
2007 mpeg_decode_sequence_extension(s); | |
2008 break; | |
1546 | 2009 case 0x2: |
2010 mpeg_decode_sequence_display_extension(s1); | |
2011 break; | |
0 | 2012 case 0x3: |
2013 mpeg_decode_quant_matrix_extension(s); | |
2014 break; | |
1546 | 2015 case 0x7: |
2016 mpeg_decode_picture_display_extension(s1); | |
2017 break; | |
0 | 2018 case 0x8: |
2019 mpeg_decode_picture_coding_extension(s); | |
2020 break; | |
2021 } | |
2022 } | |
2023 | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2024 static void exchange_uv(MpegEncContext *s){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2025 short * tmp; |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2026 |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2027 tmp = s->pblocks[4]; |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2028 s->pblocks[4] = s->pblocks[5]; |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2029 s->pblocks[5] = tmp; |
1380 | 2030 } |
2031 | |
826 | 2032 #define DECODE_SLICE_FATAL_ERROR -2 |
2033 #define DECODE_SLICE_ERROR -1 | |
2034 #define DECODE_SLICE_OK 0 | |
2035 | |
2036 /** | |
2037 * decodes a slice. | |
2038 * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br> | |
2039 * DECODE_SLICE_ERROR if the slice is damaged<br> | |
2040 * DECODE_SLICE_OK if this slice is ok<br> | |
2041 */ | |
0 | 2042 static int mpeg_decode_slice(AVCodecContext *avctx, |
925 | 2043 AVFrame *pict, |
0 | 2044 int start_code, |
1211 | 2045 uint8_t **buf, int buf_size) |
0 | 2046 { |
2047 Mpeg1Context *s1 = avctx->priv_data; | |
2048 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
2049 int ret; | |
1096
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
2050 const int field_pic= s->picture_structure != PICT_FRAME; |
0 | 2051 |
1285 | 2052 s->resync_mb_x= s->mb_x = |
2053 s->resync_mb_y= s->mb_y = -1; | |
2054 | |
0 | 2055 start_code = (start_code - 1) & 0xff; |
568 | 2056 if (start_code >= s->mb_height){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
2057 av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", start_code, s->mb_height); |
1285 | 2058 return -1; |
568 | 2059 } |
1160 | 2060 |
2061 ff_mpeg1_clean_buffers(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:
1164
diff
changeset
|
2062 s->interlaced_dct = 0; |
1096
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
2063 |
0 | 2064 /* start frame decoding */ |
1138 | 2065 if (s->first_slice) { |
2066 if(s->first_field || s->picture_structure==PICT_FRAME){ | |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
751
diff
changeset
|
2067 if(MPV_frame_start(s, avctx) < 0) |
826 | 2068 return DECODE_SLICE_FATAL_ERROR; |
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:
1164
diff
changeset
|
2069 |
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:
1164
diff
changeset
|
2070 ff_er_frame_start(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:
1164
diff
changeset
|
2071 |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
2072 /* first check if we must repeat the frame */ |
1409 | 2073 s->current_picture_ptr->repeat_pict = 0; |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
2074 if (s->repeat_first_field) { |
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
2075 if (s->progressive_sequence) { |
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
2076 if (s->top_field_first) |
1409 | 2077 s->current_picture_ptr->repeat_pict = 4; |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
2078 else |
1409 | 2079 s->current_picture_ptr->repeat_pict = 2; |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
2080 } else if (s->progressive_frame) { |
1409 | 2081 s->current_picture_ptr->repeat_pict = 1; |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
2082 } |
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
2083 } |
1546 | 2084 |
2085 *s->current_picture_ptr->pan_scan= s1->pan_scan; | |
1138 | 2086 }else{ //second field |
2087 int i; | |
1182
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
2088 |
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
2089 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
2090 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n"); |
1182
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
2091 return -1; |
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
2092 } |
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
2093 |
1138 | 2094 for(i=0; i<4; i++){ |
2095 s->current_picture.data[i] = s->current_picture_ptr->data[i]; | |
2096 if(s->picture_structure == PICT_BOTTOM_FIELD){ | |
2097 s->current_picture.data[i] += s->current_picture_ptr->linesize[i]; | |
2098 } | |
2099 } | |
2100 } | |
1381 | 2101 #ifdef HAVE_XVMC |
2102 // MPV_frame_start will call this function too, | |
2103 // but we need to call it on every field | |
2104 if(s->avctx->xvmc_acceleration) | |
2105 XVMC_field_start(s,avctx); | |
2106 #endif | |
2107 }//fi(s->first_slice) | |
0 | 2108 |
1211 | 2109 init_get_bits(&s->gb, *buf, buf_size*8); |
0 | 2110 |
54 | 2111 s->qscale = get_qscale(s); |
1690 | 2112 if (s->first_slice && (s->first_field || s->picture_structure==PICT_FRAME)) { |
2113 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1708 | 2114 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%2d%2d%2d%2d %s %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n", |
1690 | 2115 s->qscale, s->mpeg_f_code[0][0],s->mpeg_f_code[0][1],s->mpeg_f_code[1][0],s->mpeg_f_code[1][1], |
2116 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), | |
1708 | 2117 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", |
1690 | 2118 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors, |
2119 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :""); | |
2120 } | |
2121 } | |
2122 | |
2123 s->first_slice = 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:
1164
diff
changeset
|
2124 if(s->qscale == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
2125 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n"); |
1285 | 2126 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:
1164
diff
changeset
|
2127 } |
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:
1164
diff
changeset
|
2128 |
0 | 2129 /* extra slice info */ |
21 | 2130 while (get_bits1(&s->gb) != 0) { |
2131 skip_bits(&s->gb, 8); | |
0 | 2132 } |
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:
1164
diff
changeset
|
2133 |
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:
1164
diff
changeset
|
2134 s->mb_x=0; |
0 | 2135 |
716 | 2136 for(;;) { |
2137 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 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:
1164
diff
changeset
|
2138 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
2139 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n"); |
1285 | 2140 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:
1164
diff
changeset
|
2141 } |
716 | 2142 if (code >= 33) { |
2143 if (code == 33) { | |
2144 s->mb_x += 33; | |
2145 } | |
2146 /* otherwise, stuffing, nothing to do */ | |
2147 } else { | |
2148 s->mb_x += code; | |
2149 break; | |
2150 } | |
2151 } | |
1160 | 2152 |
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:
1164
diff
changeset
|
2153 s->resync_mb_x= s->mb_x; |
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:
1164
diff
changeset
|
2154 s->resync_mb_y= s->mb_y = start_code; |
1160 | 2155 s->mb_skip_run= 0; |
1389 | 2156 ff_init_block_index(s); |
716 | 2157 |
0 | 2158 for(;;) { |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2159 #ifdef HAVE_XVMC |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2160 //one 1 we memcpy blocks in xvmcvideo |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2161 if(s->avctx->xvmc_acceleration > 1) |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2162 XVMC_init_block(s);//set s->block |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2163 #endif |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2164 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
844
diff
changeset
|
2165 s->dsp.clear_blocks(s->block[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:
1164
diff
changeset
|
2166 |
12
4d50c7d89e0f
use block[] in structure to have it aligned on 8 bytes for mmx optimizations
glantau
parents:
7
diff
changeset
|
2167 ret = mpeg_decode_mb(s, s->block); |
1644 | 2168 s->chroma_qscale= s->qscale; |
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:
1164
diff
changeset
|
2169 |
0 | 2170 dprintf("ret=%d\n", ret); |
2171 if (ret < 0) | |
2172 return -1; | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2173 |
1692 | 2174 if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs |
2175 const int wrap = field_pic ? 2*s->block_wrap[0] : s->block_wrap[0]; | |
2176 int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap; | |
1691
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2177 int motion_for_top_x, motion_for_top_y, motion_back_top_x, motion_back_top_y; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2178 int motion_for_bottom_x, motion_for_bottom_y, motion_back_bottom_x, motion_back_bottom_y; |
1692 | 2179 if(field_pic && !s->first_field) |
2180 xy += wrap/2; | |
2181 | |
1285 | 2182 if (s->mb_intra) { |
1691
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2183 motion_for_top_x = motion_for_top_y = motion_back_top_x = motion_back_top_y = |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2184 motion_for_bottom_x = motion_for_bottom_y = motion_back_bottom_x = motion_back_bottom_y = 0; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2185 }else if (s->mv_type == MV_TYPE_16X16){ |
1691
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2186 motion_for_top_x = motion_for_bottom_x = s->mv[0][0][0]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2187 motion_for_top_y = motion_for_bottom_y = s->mv[0][0][1]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2188 motion_back_top_x = motion_back_bottom_x = s->mv[1][0][0]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2189 motion_back_top_y = motion_back_bottom_y = s->mv[1][0][1]; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2190 } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ { |
1691
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2191 motion_for_top_x = s->mv[0][0][0]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2192 motion_for_top_y = s->mv[0][0][1]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2193 motion_for_bottom_x = s->mv[0][1][0]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2194 motion_for_bottom_y = s->mv[0][1][1]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2195 motion_back_top_x = s->mv[1][0][0]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2196 motion_back_top_y = s->mv[1][0][1]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2197 motion_back_bottom_x = s->mv[1][1][0]; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2198 motion_back_bottom_y = s->mv[1][1][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:
1164
diff
changeset
|
2199 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2200 |
1691
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2201 s->current_picture.motion_val[0][xy][0] = motion_for_top_x; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2202 s->current_picture.motion_val[0][xy][1] = motion_for_top_y; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2203 s->current_picture.motion_val[0][xy + 1][0] = motion_for_top_x; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2204 s->current_picture.motion_val[0][xy + 1][1] = motion_for_top_y; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2205 s->current_picture.motion_val[0][xy + wrap][0] = motion_for_bottom_x; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2206 s->current_picture.motion_val[0][xy + wrap][1] = motion_for_bottom_y; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2207 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_for_bottom_x; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2208 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_for_bottom_y; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2209 |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2210 if(s->pict_type != B_TYPE){ |
1691
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2211 motion_back_top_x = motion_back_top_y = motion_back_bottom_x = motion_back_bottom_y = 0; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2212 } |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2213 |
1691
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2214 s->current_picture.motion_val[1][xy][0] = motion_back_top_x; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2215 s->current_picture.motion_val[1][xy][1] = motion_back_top_y; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2216 s->current_picture.motion_val[1][xy + 1][0] = motion_back_top_x; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2217 s->current_picture.motion_val[1][xy + 1][1] = motion_back_top_y; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2218 s->current_picture.motion_val[1][xy + wrap][0] = motion_back_bottom_x; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2219 s->current_picture.motion_val[1][xy + wrap][1] = motion_back_bottom_y; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2220 s->current_picture.motion_val[1][xy + 1 + wrap][0] = motion_back_bottom_x; |
7d8af3b5699a
cygwin fix and dont average interlaced MVs patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1690
diff
changeset
|
2221 s->current_picture.motion_val[1][xy + 1 + wrap][1] = motion_back_bottom_y; |
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:
1164
diff
changeset
|
2222 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
2223 |
1389 | 2224 s->dest[0] += 16; |
2225 s->dest[1] += 8; | |
2226 s->dest[2] += 8; | |
2227 | |
716 | 2228 MPV_decode_mb(s, s->block); |
1389 | 2229 |
716 | 2230 if (++s->mb_x >= s->mb_width) { |
1380 | 2231 |
1370 | 2232 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
716 | 2233 |
2234 s->mb_x = 0; | |
2235 s->mb_y++; | |
1289
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2236 |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2237 if(s->mb_y<<field_pic >= s->mb_height){ |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2238 int left= s->gb.size_in_bits - get_bits_count(&s->gb); |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2239 |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2240 if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23))) |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2241 || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
2242 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d\n", left); |
1289
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2243 return -1; |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2244 }else |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2245 goto eos; |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2246 } |
1389 | 2247 |
2248 ff_init_block_index(s); | |
716 | 2249 } |
2250 | |
2251 /* skip mb handling */ | |
1160 | 2252 if (s->mb_skip_run == -1) { |
716 | 2253 /* read again increment */ |
1160 | 2254 s->mb_skip_run = 0; |
716 | 2255 for(;;) { |
2256 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 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:
1164
diff
changeset
|
2257 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
2258 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n"); |
1181 | 2259 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:
1164
diff
changeset
|
2260 } |
716 | 2261 if (code >= 33) { |
2262 if (code == 33) { | |
1160 | 2263 s->mb_skip_run += 33; |
1181 | 2264 }else if(code == 35){ |
2265 if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
2266 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n"); |
1181 | 2267 return -1; |
2268 } | |
2269 goto eos; /* end of slice */ | |
716 | 2270 } |
2271 /* otherwise, stuffing, nothing to do */ | |
2272 } else { | |
1160 | 2273 s->mb_skip_run += code; |
716 | 2274 break; |
2275 } | |
2276 } | |
2277 } | |
0 | 2278 } |
1285 | 2279 eos: // end of slice |
2280 *buf += get_bits_count(&s->gb)/8 - 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:
1164
diff
changeset
|
2281 //printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y); |
1285 | 2282 return 0; |
2283 } | |
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:
1164
diff
changeset
|
2284 |
1285 | 2285 /** |
2286 * handles slice ends. | |
2287 * @return 1 if it seems to be the last slice of | |
2288 */ | |
2289 static int slice_end(AVCodecContext *avctx, AVFrame *pict) | |
2290 { | |
2291 Mpeg1Context *s1 = avctx->priv_data; | |
2292 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
2293 | |
1402
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1389
diff
changeset
|
2294 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr) |
1311
fc858abf6b10
fixed segfault if sequence header has not been found before slice decoding
bellard
parents:
1289
diff
changeset
|
2295 return 0; |
fc858abf6b10
fixed segfault if sequence header has not been found before slice decoding
bellard
parents:
1289
diff
changeset
|
2296 |
1381 | 2297 #ifdef HAVE_XVMC |
2298 if(s->avctx->xvmc_acceleration) | |
2299 XVMC_field_end(s); | |
2300 #endif | |
0 | 2301 /* end of slice reached */ |
1285 | 2302 if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) { |
0 | 2303 /* end of image */ |
903 | 2304 |
1421 | 2305 if(s->codec_id == CODEC_ID_MPEG2VIDEO){ |
1196 | 2306 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2; |
2307 }else | |
2308 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1; | |
2309 | |
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:
1164
diff
changeset
|
2310 ff_er_frame_end(s); |
0 | 2311 |
2312 MPV_frame_end(s); | |
2313 | |
924 | 2314 if (s->pict_type == B_TYPE || s->low_delay) { |
1328 | 2315 *pict= *(AVFrame*)s->current_picture_ptr; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1697
diff
changeset
|
2316 ff_print_debug_info(s, pict); |
0 | 2317 } else { |
903 | 2318 s->picture_number++; |
0 | 2319 /* latency of 1 frame for I and P frames */ |
2320 /* XXX: use another variable than picture_number */ | |
1211 | 2321 if (s->last_picture_ptr != NULL) { |
1328 | 2322 *pict= *(AVFrame*)s->last_picture_ptr; |
1706
3ba5c493db6f
motion vector vissualization improvements patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1697
diff
changeset
|
2323 ff_print_debug_info(s, pict); |
0 | 2324 } |
2325 } | |
1380 | 2326 |
1285 | 2327 return 1; |
0 | 2328 } else { |
1285 | 2329 return 0; |
0 | 2330 } |
2331 } | |
2332 | |
2333 static int mpeg1_decode_sequence(AVCodecContext *avctx, | |
1064 | 2334 uint8_t *buf, int buf_size) |
0 | 2335 { |
2336 Mpeg1Context *s1 = avctx->priv_data; | |
2337 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
38
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
2338 int width, height, i, v, j; |
917 | 2339 float aspect; |
401
e20655449d4a
mpeg1/2 identifier - fixed frame rate for some bad mpeg1 streams
glantau
parents:
391
diff
changeset
|
2340 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1021
diff
changeset
|
2341 init_get_bits(&s->gb, buf, buf_size*8); |
0 | 2342 |
2343 width = get_bits(&s->gb, 12); | |
2344 height = get_bits(&s->gb, 12); | |
917 | 2345 s->aspect_ratio_info= get_bits(&s->gb, 4); |
1674
835964e33ba2
fixed potential problem if aspect_ratio_info == 0 for MPEG stream - fixed aspect ratio problem if CODEC_ID_MPEG2VIDEO is used to decode an MPEG1 stream (which is the recommended codec id for mpeg video)
bellard
parents:
1673
diff
changeset
|
2346 if (s->aspect_ratio_info == 0) |
835964e33ba2
fixed potential problem if aspect_ratio_info == 0 for MPEG stream - fixed aspect ratio problem if CODEC_ID_MPEG2VIDEO is used to decode an MPEG1 stream (which is the recommended codec id for mpeg video)
bellard
parents:
1673
diff
changeset
|
2347 return -1; |
835964e33ba2
fixed potential problem if aspect_ratio_info == 0 for MPEG stream - fixed aspect ratio problem if CODEC_ID_MPEG2VIDEO is used to decode an MPEG1 stream (which is the recommended codec id for mpeg video)
bellard
parents:
1673
diff
changeset
|
2348 aspect= 1.0/mpeg1_aspect[s->aspect_ratio_info]; |
835964e33ba2
fixed potential problem if aspect_ratio_info == 0 for MPEG stream - fixed aspect ratio problem if CODEC_ID_MPEG2VIDEO is used to decode an MPEG1 stream (which is the recommended codec id for mpeg video)
bellard
parents:
1673
diff
changeset
|
2349 avctx->sample_aspect_ratio= av_d2q(aspect, 255); |
917 | 2350 |
0 | 2351 s->frame_rate_index = get_bits(&s->gb, 4); |
2352 if (s->frame_rate_index == 0) | |
2353 return -1; | |
2354 s->bit_rate = get_bits(&s->gb, 18) * 400; | |
21 | 2355 if (get_bits1(&s->gb) == 0) /* marker */ |
0 | 2356 return -1; |
2357 if (width <= 0 || height <= 0 || | |
2358 (width % 2) != 0 || (height % 2) != 0) | |
2359 return -1; | |
2360 if (width != s->width || | |
2361 height != s->height) { | |
2362 /* start new mpeg1 context decoding */ | |
2363 s->out_format = FMT_MPEG1; | |
2364 if (s1->mpeg_enc_ctx_allocated) { | |
2365 MPV_common_end(s); | |
2366 } | |
2367 s->width = width; | |
2368 s->height = height; | |
924 | 2369 avctx->has_b_frames= 1; |
69 | 2370 s->avctx = avctx; |
0 | 2371 avctx->width = width; |
2372 avctx->height = height; | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
2373 av_reduce( |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
2374 &avctx->frame_rate, |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
2375 &avctx->frame_rate_base, |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
2376 frame_rate_tab[s->frame_rate_index], |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
2377 MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
2378 1<<30 |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
2379 ); |
0 | 2380 avctx->bit_rate = s->bit_rate; |
2381 | |
1381 | 2382 //get_format() or set_video(width,height,aspect,pix_fmt); |
2383 //until then pix_fmt may be changed right after codec init | |
2384 if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT ) | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2385 if( avctx->idct_algo == FF_IDCT_AUTO ) |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2386 avctx->idct_algo = FF_IDCT_SIMPLE; |
1381 | 2387 |
0 | 2388 if (MPV_common_init(s) < 0) |
2389 return -1; | |
2390 s1->mpeg_enc_ctx_allocated = 1; | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2391 s->swap_uv = 0;//just in case vcr2 and mpeg2 stream have been concatinated |
0 | 2392 } |
2393 | |
21 | 2394 skip_bits(&s->gb, 10); /* vbv_buffer_size */ |
2395 skip_bits(&s->gb, 1); | |
0 | 2396 |
2397 /* get matrix */ | |
21 | 2398 if (get_bits1(&s->gb)) { |
0 | 2399 for(i=0;i<64;i++) { |
2400 v = get_bits(&s->gb, 8); | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2401 j = s->intra_scantable.permutated[i]; |
38
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
2402 s->intra_matrix[j] = v; |
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
2403 s->chroma_intra_matrix[j] = v; |
0 | 2404 } |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2405 #ifdef DEBUG |
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2406 dprintf("intra matrix present\n"); |
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2407 for(i=0;i<64;i++) |
710
97377ab86647
forgot zigzag_direct[] behind #ifdef DEBUG (found by Klaas-Pieter Vlieg <vlieg at eurescom dot de>)
michaelni
parents:
706
diff
changeset
|
2408 dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]); |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2409 printf("\n"); |
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2410 #endif |
0 | 2411 } else { |
2412 for(i=0;i<64;i++) { | |
1092 | 2413 int j= s->dsp.idct_permutation[i]; |
533
3c07cf9595de
adding ff prefix to avoid global name conficts with xvid (patch by Marko Kreen <marko at l-t.ee>)
michaelni
parents:
520
diff
changeset
|
2414 v = ff_mpeg1_default_intra_matrix[i]; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2415 s->intra_matrix[j] = v; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2416 s->chroma_intra_matrix[j] = v; |
0 | 2417 } |
2418 } | |
21 | 2419 if (get_bits1(&s->gb)) { |
0 | 2420 for(i=0;i<64;i++) { |
2421 v = get_bits(&s->gb, 8); | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2422 j = s->intra_scantable.permutated[i]; |
344 | 2423 s->inter_matrix[j] = v; |
2424 s->chroma_inter_matrix[j] = v; | |
0 | 2425 } |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2426 #ifdef DEBUG |
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2427 dprintf("non intra matrix present\n"); |
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2428 for(i=0;i<64;i++) |
710
97377ab86647
forgot zigzag_direct[] behind #ifdef DEBUG (found by Klaas-Pieter Vlieg <vlieg at eurescom dot de>)
michaelni
parents:
706
diff
changeset
|
2429 dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]); |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2430 printf("\n"); |
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2431 #endif |
0 | 2432 } else { |
2433 for(i=0;i<64;i++) { | |
1092 | 2434 int j= s->dsp.idct_permutation[i]; |
533
3c07cf9595de
adding ff prefix to avoid global name conficts with xvid (patch by Marko Kreen <marko at l-t.ee>)
michaelni
parents:
520
diff
changeset
|
2435 v = ff_mpeg1_default_non_intra_matrix[i]; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2436 s->inter_matrix[j] = v; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2437 s->chroma_inter_matrix[j] = v; |
0 | 2438 } |
2439 } | |
2440 | |
2441 /* we set mpeg2 parameters so that it emulates mpeg1 */ | |
2442 s->progressive_sequence = 1; | |
2443 s->progressive_frame = 1; | |
2444 s->picture_structure = PICT_FRAME; | |
2445 s->frame_pred_frame_dct = 1; | |
1421 | 2446 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO; |
401
e20655449d4a
mpeg1/2 identifier - fixed frame rate for some bad mpeg1 streams
glantau
parents:
391
diff
changeset
|
2447 avctx->sub_id = 1; /* indicates mpeg1 */ |
1672 | 2448 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1; |
0 | 2449 return 0; |
2450 } | |
2451 | |
1376 | 2452 static int vcr2_init_sequence(AVCodecContext *avctx) |
2453 { | |
2454 Mpeg1Context *s1 = avctx->priv_data; | |
2455 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
1377 | 2456 int i, v; |
1376 | 2457 |
2458 /* start new mpeg1 context decoding */ | |
2459 s->out_format = FMT_MPEG1; | |
2460 if (s1->mpeg_enc_ctx_allocated) { | |
2461 MPV_common_end(s); | |
2462 } | |
2463 s->width = avctx->width; | |
2464 s->height = avctx->height; | |
2465 avctx->has_b_frames= 0; //true? | |
1380 | 2466 s->low_delay= 1; |
1376 | 2467 s->avctx = avctx; |
1381 | 2468 |
2469 //get_format() or set_video(width,height,aspect,pix_fmt); | |
2470 //until then pix_fmt may be changed right after codec init | |
2471 if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT ) | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2472 if( avctx->idct_algo == FF_IDCT_AUTO ) |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2473 avctx->idct_algo = FF_IDCT_SIMPLE; |
1376 | 2474 |
2475 if (MPV_common_init(s) < 0) | |
2476 return -1; | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2477 exchange_uv(s);//common init reset pblocks, so we swap them here |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2478 s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB |
1376 | 2479 s1->mpeg_enc_ctx_allocated = 1; |
2480 | |
2481 for(i=0;i<64;i++) { | |
2482 int j= s->dsp.idct_permutation[i]; | |
2483 v = ff_mpeg1_default_intra_matrix[i]; | |
2484 s->intra_matrix[j] = v; | |
2485 s->chroma_intra_matrix[j] = v; | |
2486 | |
2487 v = ff_mpeg1_default_non_intra_matrix[i]; | |
2488 s->inter_matrix[j] = v; | |
2489 s->chroma_inter_matrix[j] = v; | |
2490 } | |
2491 | |
2492 s->progressive_sequence = 1; | |
2493 s->progressive_frame = 1; | |
2494 s->picture_structure = PICT_FRAME; | |
2495 s->frame_pred_frame_dct = 1; | |
1421 | 2496 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO; |
1377 | 2497 avctx->sub_id = 2; /* indicates mpeg2 */ |
1376 | 2498 return 0; |
2499 } | |
2500 | |
2501 | |
1084 | 2502 static void mpeg_decode_user_data(AVCodecContext *avctx, |
2503 const uint8_t *buf, int buf_size) | |
2504 { | |
2505 const uint8_t *p; | |
2506 int len, flags; | |
2507 p = buf; | |
2508 len = buf_size; | |
2509 | |
2510 /* we parse the DTG active format information */ | |
2511 if (len >= 5 && | |
2512 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') { | |
2513 flags = p[4]; | |
2514 p += 5; | |
2515 len -= 5; | |
2516 if (flags & 0x80) { | |
2517 /* skip event id */ | |
2518 if (len < 2) | |
2519 return; | |
2520 p += 2; | |
2521 len -= 2; | |
2522 } | |
2523 if (flags & 0x40) { | |
2524 if (len < 1) | |
2525 return; | |
2526 avctx->dtg_active_format = p[0] & 0x0f; | |
2527 } | |
2528 } | |
2529 } | |
2530 | |
1211 | 2531 /** |
2532 * finds the end of the current frame in the bitstream. | |
2533 * @return the position of the first byte of the next frame, or -1 | |
2534 */ | |
2535 static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){ | |
2536 ParseContext *pc= &s->parse_context; | |
2537 int i; | |
2538 uint32_t state; | |
2539 | |
2540 state= pc->state; | |
2541 | |
2542 i=0; | |
2543 if(!pc->frame_start_found){ | |
2544 for(i=0; i<buf_size; i++){ | |
2545 state= (state<<8) | buf[i]; | |
2546 if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){ | |
2547 i++; | |
2548 pc->frame_start_found=1; | |
2549 break; | |
2550 } | |
2551 } | |
2552 } | |
2553 | |
2554 if(pc->frame_start_found){ | |
2555 for(; i<buf_size; i++){ | |
2556 state= (state<<8) | buf[i]; | |
2557 if((state&0xFFFFFF00) == 0x100){ | |
2558 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){ | |
2559 pc->frame_start_found=0; | |
2560 pc->state=-1; | |
2561 return i-3; | |
2562 } | |
2563 } | |
2564 } | |
2565 } | |
2566 pc->state= state; | |
1218
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1211
diff
changeset
|
2567 return END_NOT_FOUND; |
1211 | 2568 } |
2569 | |
0 | 2570 /* handle buffering and image synchronisation */ |
2571 static int mpeg_decode_frame(AVCodecContext *avctx, | |
2572 void *data, int *data_size, | |
1064 | 2573 uint8_t *buf, int buf_size) |
0 | 2574 { |
2575 Mpeg1Context *s = avctx->priv_data; | |
1211 | 2576 uint8_t *buf_end, *buf_ptr; |
2577 int ret, start_code, input_size; | |
925 | 2578 AVFrame *picture = data; |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
2579 MpegEncContext *s2 = &s->mpeg_enc_ctx; |
0 | 2580 dprintf("fill_buffer\n"); |
2581 | |
2582 *data_size = 0; | |
344 | 2583 |
0 | 2584 /* special case for last picture */ |
1372 | 2585 if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) { |
2586 *picture= *(AVFrame*)s2->next_picture_ptr; | |
2587 s2->next_picture_ptr= NULL; | |
903 | 2588 |
1372 | 2589 *data_size = sizeof(AVFrame); |
0 | 2590 return 0; |
2591 } | |
2592 | |
1211 | 2593 if(s2->flags&CODEC_FLAG_TRUNCATED){ |
1218
358bbc952e27
10l (returning negative number of consumed bytes if the first startcode of a frame was split between 2 buffers)
michaelni
parents:
1211
diff
changeset
|
2594 int next= mpeg1_find_frame_end(s2, buf, buf_size); |
1211 | 2595 |
2596 if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 ) | |
2597 return buf_size; | |
2598 } | |
2599 | |
0 | 2600 buf_ptr = buf; |
2601 buf_end = buf + buf_size; | |
383
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2602 |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2603 #if 0 |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2604 if (s->repeat_field % 2 == 1) { |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
2605 s->repeat_field++; |
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
2606 //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number, |
383
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2607 // s2->picture_number, s->repeat_field); |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2608 if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) { |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2609 *data_size = sizeof(AVPicture); |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2610 goto the_end; |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2611 } |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
2612 } |
383
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2613 #endif |
1376 | 2614 |
2615 if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2")) | |
2616 vcr2_init_sequence(avctx); | |
2617 | |
1211 | 2618 for(;;) { |
0 | 2619 /* find start next code */ |
1211 | 2620 start_code = find_start_code(&buf_ptr, buf_end); |
1220 | 2621 if (start_code < 0){ |
1484 | 2622 if(s2->pict_type != B_TYPE || avctx->hurry_up==0){ |
2623 if (slice_end(avctx, picture)) { | |
1672 | 2624 if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice |
1484 | 2625 *data_size = sizeof(AVPicture); |
2626 } | |
1285 | 2627 } |
1220 | 2628 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index); |
0 | 2629 } |
1289
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2630 |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2631 input_size = buf_end - buf_ptr; |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2632 |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2633 if(avctx->debug & FF_DEBUG_STARTCODE){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
2634 av_log(avctx, AV_LOG_DEBUG, "%3X at %d left %d\n", start_code, buf_ptr-buf, input_size); |
1289
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2635 } |
1211 | 2636 |
0 | 2637 /* prepare data for next start code */ |
2638 switch(start_code) { | |
2639 case SEQ_START_CODE: | |
1211 | 2640 mpeg1_decode_sequence(avctx, buf_ptr, |
0 | 2641 input_size); |
2642 break; | |
2643 | |
2644 case PICTURE_START_CODE: | |
2645 /* we have a complete image : we try to decompress it */ | |
2646 mpeg1_decode_picture(avctx, | |
1211 | 2647 buf_ptr, input_size); |
0 | 2648 break; |
2649 case EXT_START_CODE: | |
2650 mpeg_decode_extension(avctx, | |
1211 | 2651 buf_ptr, input_size); |
0 | 2652 break; |
1084 | 2653 case USER_START_CODE: |
2654 mpeg_decode_user_data(avctx, | |
1211 | 2655 buf_ptr, input_size); |
1084 | 2656 break; |
1348 | 2657 case GOP_START_CODE: |
2658 s2->first_field=0; | |
2659 break; | |
0 | 2660 default: |
2661 if (start_code >= SLICE_MIN_START_CODE && | |
911 | 2662 start_code <= SLICE_MAX_START_CODE) { |
917 | 2663 |
2664 /* skip b frames if we dont have reference frames */ | |
1138 | 2665 if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break; |
917 | 2666 /* skip b frames if we are in a hurry */ |
2667 if(avctx->hurry_up && s2->pict_type==B_TYPE) break; | |
2668 /* skip everything if we are in a hurry>=5 */ | |
2669 if(avctx->hurry_up>=5) break; | |
1211 | 2670 |
1182
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
2671 if (!s->mpeg_enc_ctx_allocated) break; |
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
2672 |
0 | 2673 ret = mpeg_decode_slice(avctx, picture, |
1211 | 2674 start_code, &buf_ptr, input_size); |
1285 | 2675 emms_c(); |
1096
5e6e505d8997
field picture decoding support (16x16 MC blocks only as i dont have any samples which use other modes ...)
michaelni
parents:
1092
diff
changeset
|
2676 |
1285 | 2677 if(ret < 0){ |
2678 if(s2->resync_mb_x>=0 && s2->resync_mb_y>=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:
1164
diff
changeset
|
2679 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, AC_ERROR|DC_ERROR|MV_ERROR); |
1285 | 2680 if(ret==DECODE_SLICE_FATAL_ERROR) return -1; |
2681 }else{ | |
2682 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END); | |
0 | 2683 } |
2684 } | |
2685 break; | |
2686 } | |
2687 } | |
2688 } | |
2689 | |
2690 static int mpeg_decode_end(AVCodecContext *avctx) | |
2691 { | |
2692 Mpeg1Context *s = avctx->priv_data; | |
2693 | |
2694 if (s->mpeg_enc_ctx_allocated) | |
2695 MPV_common_end(&s->mpeg_enc_ctx); | |
2696 return 0; | |
2697 } | |
2698 | |
1423 | 2699 AVCodec mpeg1video_decoder = { |
2700 "mpeg1video", | |
0 | 2701 CODEC_TYPE_VIDEO, |
2702 CODEC_ID_MPEG1VIDEO, | |
2703 sizeof(Mpeg1Context), | |
2704 mpeg_decode_init, | |
2705 NULL, | |
2706 mpeg_decode_end, | |
2707 mpeg_decode_frame, | |
842
e460775adb38
cleanup (breaks compatibility, requested by fabrice)
michaelni
parents:
826
diff
changeset
|
2708 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED, |
1368 | 2709 .flush= ff_mpeg_flush, |
0 | 2710 }; |
1381 | 2711 |
1423 | 2712 AVCodec mpeg2video_decoder = { |
2713 "mpeg2video", | |
2714 CODEC_TYPE_VIDEO, | |
2715 CODEC_ID_MPEG2VIDEO, | |
2716 sizeof(Mpeg1Context), | |
2717 mpeg_decode_init, | |
2718 NULL, | |
2719 mpeg_decode_end, | |
2720 mpeg_decode_frame, | |
2721 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED, | |
2722 .flush= ff_mpeg_flush, | |
2723 }; | |
2724 | |
1615 | 2725 //legacy decoder |
2726 AVCodec mpegvideo_decoder = { | |
2727 "mpegvideo", | |
2728 CODEC_TYPE_VIDEO, | |
2729 CODEC_ID_MPEG2VIDEO, | |
2730 sizeof(Mpeg1Context), | |
2731 mpeg_decode_init, | |
2732 NULL, | |
2733 mpeg_decode_end, | |
2734 mpeg_decode_frame, | |
2735 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED, | |
2736 .flush= ff_mpeg_flush, | |
2737 }; | |
2738 | |
1381 | 2739 #ifdef HAVE_XVMC |
2740 static int mpeg_mc_decode_init(AVCodecContext *avctx){ | |
2741 Mpeg1Context *s; | |
2742 | |
2743 if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) ) | |
2744 return -1; | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2745 if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){ |
1381 | 2746 dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n"); |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2747 } |
1381 | 2748 mpeg_decode_init(avctx); |
2749 s = avctx->priv_data; | |
2750 | |
2751 avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT; | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2752 avctx->xvmc_acceleration = 2;//2 - the blocks are packed! |
1381 | 2753 |
2754 return 0; | |
2755 } | |
2756 | |
2757 AVCodec mpeg_xvmc_decoder = { | |
2758 "mpegvideo_xvmc", | |
2759 CODEC_TYPE_VIDEO, | |
2760 CODEC_ID_MPEG2VIDEO_XVMC, | |
2761 sizeof(Mpeg1Context), | |
2762 mpeg_mc_decode_init, | |
2763 NULL, | |
2764 mpeg_decode_end, | |
2765 mpeg_decode_frame, | |
2766 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED, | |
2767 }; | |
2768 | |
2769 #endif | |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
2770 |
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
2771 /* this is ugly i know, but the alternative is too make |
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
2772 hundreds of vars global and prefix them with ff_mpeg1_ |
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
2773 which is far uglier. */ |
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
2774 #include "mdec.c" |