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