Mercurial > libavcodec.hg
annotate mpeg12.c @ 5591:642588a60570 libavcodec
update mmx code to latest snow changes
note, the code likely can overflow and thus needs some more changes
sse2 updated too but disabled as it is untested
author | michael |
---|---|
date | Sat, 25 Aug 2007 15:20:56 +0000 |
parents | ebe106e3339e |
children | 14a9ceb162d2 |
rev | line source |
---|---|
0 | 1 /* |
5208 | 2 * MPEG1/2 decoder |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
2967 | 4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
429 | 9 * modify it under the terms of the GNU Lesser General Public |
10 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
0 | 12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
0 | 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 * Lesser General Public License for more details. | |
0 | 17 * |
429 | 18 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 21 */ |
2967 | 22 |
1106 | 23 /** |
24 * @file mpeg12.c | |
5208 | 25 * MPEG1/2 decoder |
1106 | 26 */ |
2967 | 27 |
76 | 28 //#define DEBUG |
0 | 29 #include "avcodec.h" |
30 #include "dsputil.h" | |
31 #include "mpegvideo.h" | |
32 | |
5208 | 33 #include "mpeg12.h" |
0 | 34 #include "mpeg12data.h" |
5208 | 35 #include "mpeg12decdata.h" |
4623
e541c0dd35dd
imx dump header bitstream filter, modifies bitstream to fit in mov and be decoded by final cut pro decoder
bcoudurier
parents:
4621
diff
changeset
|
36 #include "bytestream.h" |
0 | 37 |
1708 | 38 //#undef NDEBUG |
39 //#include <assert.h> | |
40 | |
694 | 41 |
552 | 42 #define DC_VLC_BITS 9 |
43 #define MV_VLC_BITS 9 | |
44 #define MBINCR_VLC_BITS 9 | |
45 #define MB_PAT_VLC_BITS 9 | |
46 #define MB_PTYPE_VLC_BITS 6 | |
47 #define MB_BTYPE_VLC_BITS 6 | |
48 #define TEX_VLC_BITS 9 | |
49 | |
2967 | 50 static inline int mpeg1_decode_block_inter(MpegEncContext *s, |
51 DCTELEM *block, | |
711 | 52 int n); |
2967 | 53 static inline int mpeg1_decode_block_intra(MpegEncContext *s, |
54 DCTELEM *block, | |
0 | 55 int n); |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
56 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n); |
2967 | 57 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, |
58 DCTELEM *block, | |
0 | 59 int n); |
2967 | 60 static inline int mpeg2_decode_block_intra(MpegEncContext *s, |
61 DCTELEM *block, | |
0 | 62 int n); |
2201 | 63 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, DCTELEM *block, int n); |
2622 | 64 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, DCTELEM *block, int n); |
0 | 65 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred); |
1620 | 66 static void exchange_uv(MpegEncContext *s); |
0 | 67 |
1381 | 68 extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx); |
69 extern int XVMC_field_end(MpegEncContext *s); | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
70 extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp); |
1620 | 71 extern void XVMC_init_block(MpegEncContext *s);//set s->block |
1381 | 72 |
4180 | 73 static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1}; |
74 static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1}; | |
75 static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1}; | |
76 static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = { | |
1821 | 77 PIX_FMT_XVMC_MPEG2_IDCT, |
78 PIX_FMT_XVMC_MPEG2_MC, | |
2979 | 79 -1}; |
281
1fc96b02142e
mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents:
277
diff
changeset
|
80 |
5210 | 81 uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3]; |
4668 | 82 |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2302
diff
changeset
|
83 static void init_2d_vlc_rl(RLTable *rl, int use_static) |
552 | 84 { |
620
a5aa53b6e648
warning patch by (Dominik Mierzejewski <dominik at rangers dot eu dot org>)
michaelni
parents:
617
diff
changeset
|
85 int i; |
2967 | 86 |
87 init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, | |
552 | 88 &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
|
89 &rl->table_vlc[0][0], 4, 2, use_static); |
552 | 90 |
2967 | 91 if(use_static) |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2302
diff
changeset
|
92 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
|
93 else |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2302
diff
changeset
|
94 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
|
95 |
552 | 96 for(i=0; i<rl->vlc.table_size; i++){ |
97 int code= rl->vlc.table[i][0]; | |
98 int len = rl->vlc.table[i][1]; | |
99 int level, run; | |
2967 | 100 |
552 | 101 if(len==0){ // illegal code |
102 run= 65; | |
103 level= MAX_LEVEL; | |
104 }else if(len<0){ //more bits needed | |
105 run= 0; | |
106 level= code; | |
107 }else{ | |
108 if(code==rl->n){ //esc | |
109 run= 65; | |
110 level= 0; | |
111 }else if(code==rl->n+1){ //eob | |
711 | 112 run= 0; |
113 level= 127; | |
552 | 114 }else{ |
115 run= rl->table_run [code] + 1; | |
116 level= rl->table_level[code]; | |
117 } | |
118 } | |
119 rl->rl_vlc[0][i].len= len; | |
120 rl->rl_vlc[0][i].level= level; | |
121 rl->rl_vlc[0][i].run= run; | |
122 } | |
123 } | |
124 | |
5210 | 125 void ff_mpeg12_common_init(MpegEncContext *s) |
498 | 126 { |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
127 |
498 | 128 s->y_dc_scale_table= |
1992 | 129 s->c_dc_scale_table= mpeg2_dc_scale_table[s->intra_dc_precision]; |
1903 | 130 |
498 | 131 } |
132 | |
1325 | 133 void ff_mpeg1_clean_buffers(MpegEncContext *s){ |
134 s->last_dc[0] = 1 << (7 + s->intra_dc_precision); | |
135 s->last_dc[1] = s->last_dc[0]; | |
136 s->last_dc[2] = s->last_dc[0]; | |
137 memset(s->last_mv, 0, sizeof(s->last_mv)); | |
138 } | |
139 | |
0 | 140 |
141 /******************************************/ | |
142 /* decoding */ | |
143 | |
144 static VLC dc_lum_vlc; | |
145 static VLC dc_chroma_vlc; | |
146 static VLC mv_vlc; | |
147 static VLC mbincr_vlc; | |
148 static VLC mb_ptype_vlc; | |
149 static VLC mb_btype_vlc; | |
150 static VLC mb_pat_vlc; | |
151 | |
1904 | 152 static void init_vlcs(void) |
0 | 153 { |
154 static int done = 0; | |
155 | |
156 if (!done) { | |
494 | 157 done = 1; |
0 | 158 |
2967 | 159 init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, |
5210 | 160 ff_mpeg12_vlc_dc_lum_bits, 1, 1, |
161 ff_mpeg12_vlc_dc_lum_code, 2, 2, 1); | |
2967 | 162 init_vlc(&dc_chroma_vlc, DC_VLC_BITS, 12, |
5210 | 163 ff_mpeg12_vlc_dc_chroma_bits, 1, 1, |
164 ff_mpeg12_vlc_dc_chroma_code, 2, 2, 1); | |
2967 | 165 init_vlc(&mv_vlc, MV_VLC_BITS, 17, |
5210 | 166 &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1, |
167 &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 1); | |
2967 | 168 init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36, |
5210 | 169 &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1, |
170 &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 1); | |
1853 | 171 init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 64, |
5210 | 172 &ff_mpeg12_mbPatTable[0][1], 2, 1, |
173 &ff_mpeg12_mbPatTable[0][0], 2, 1, 1); | |
2967 | 174 |
175 init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7, | |
0 | 176 &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
|
177 &table_mb_ptype[0][0], 2, 1, 1); |
2967 | 178 init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11, |
0 | 179 &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
|
180 &table_mb_btype[0][0], 2, 1, 1); |
5210 | 181 init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]); |
182 init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]); | |
552 | 183 |
5210 | 184 init_2d_vlc_rl(&ff_rl_mpeg1, 1); |
185 init_2d_vlc_rl(&ff_rl_mpeg2, 1); | |
0 | 186 } |
187 } | |
188 | |
189 static inline int get_dmv(MpegEncContext *s) | |
190 { | |
2967 | 191 if(get_bits1(&s->gb)) |
21 | 192 return 1 - (get_bits1(&s->gb) << 1); |
0 | 193 else |
194 return 0; | |
195 } | |
196 | |
54 | 197 static inline int get_qscale(MpegEncContext *s) |
198 { | |
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
|
199 int qscale = get_bits(&s->gb, 5); |
1728 | 200 if (s->q_scale_type) { |
201 return non_linear_qscale[qscale]; | |
202 } else { | |
203 return qscale << 1; | |
54 | 204 } |
205 } | |
206 | |
0 | 207 /* motion type (for mpeg2) */ |
208 #define MT_FIELD 1 | |
209 #define MT_FRAME 2 | |
210 #define MT_16X8 2 | |
211 #define MT_DMV 3 | |
212 | |
213 static int mpeg_decode_mb(MpegEncContext *s, | |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1841
diff
changeset
|
214 DCTELEM block[12][64]) |
0 | 215 { |
751 | 216 int i, j, k, cbp, val, mb_type, motion_type; |
2591
65874d96c2da
Typo errors patch by (QuickTime | ffmpeg gmail com>
michael
parents:
2590
diff
changeset
|
217 const int mb_block_count = 4 + (1<< s->chroma_format); |
2076 | 218 |
4652 | 219 dprintf(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y); |
0 | 220 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2624
diff
changeset
|
221 assert(s->mb_skipped==0); |
1021
2d7c9f5738de
trying to fix mb skip bug in mpeg1/2 if slices are not used
michaelni
parents:
947
diff
changeset
|
222 |
1160 | 223 if (s->mb_skip_run-- != 0) { |
0 | 224 if (s->pict_type == P_TYPE) { |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2624
diff
changeset
|
225 s->mb_skipped = 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
|
226 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; |
0 | 227 } else { |
2575 | 228 int mb_type; |
2967 | 229 |
2575 | 230 if(s->mb_x) |
231 mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]; | |
232 else | |
2967 | 233 mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in mpeg at all, |
2575 | 234 if(IS_INTRA(mb_type)) |
235 return -1; | |
2967 | 236 |
237 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= | |
2575 | 238 mb_type | MB_TYPE_SKIP; |
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
|
239 // 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
|
240 |
2967 | 241 if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2624
diff
changeset
|
242 s->mb_skipped = 1; |
0 | 243 } |
930 | 244 |
0 | 245 return 0; |
246 } | |
247 | |
248 switch(s->pict_type) { | |
249 default: | |
250 case I_TYPE: | |
21 | 251 if (get_bits1(&s->gb) == 0) { |
1376 | 252 if (get_bits1(&s->gb) == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
253 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y); |
0 | 254 return -1; |
1376 | 255 } |
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
|
256 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA; |
0 | 257 } 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
|
258 mb_type = MB_TYPE_INTRA; |
0 | 259 } |
260 break; | |
261 case P_TYPE: | |
545 | 262 mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1); |
568 | 263 if (mb_type < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
264 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y); |
0 | 265 return -1; |
568 | 266 } |
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
|
267 mb_type = ptype2mb_type[ mb_type ]; |
0 | 268 break; |
269 case B_TYPE: | |
545 | 270 mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1); |
568 | 271 if (mb_type < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
272 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y); |
0 | 273 return -1; |
568 | 274 } |
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
|
275 mb_type = btype2mb_type[ mb_type ]; |
0 | 276 break; |
277 } | |
4652 | 278 dprintf(s->avctx, "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
|
279 // 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
|
280 if (IS_INTRA(mb_type)) { |
2624 | 281 s->dsp.clear_blocks(s->block[0]); |
2967 | 282 |
2624 | 283 if(!s->chroma_y_shift){ |
284 s->dsp.clear_blocks(s->block[6]); | |
285 } | |
2967 | 286 |
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
|
287 /* 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
|
288 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
|
289 !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
|
290 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
|
291 } |
0 | 292 |
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
|
293 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
|
294 s->qscale = get_qscale(s); |
2967 | 295 |
0 | 296 if (s->concealment_motion_vectors) { |
297 /* just parse them */ | |
2967 | 298 if (s->picture_structure != PICT_FRAME) |
21 | 299 skip_bits1(&s->gb); /* field select */ |
2967 | 300 |
301 s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] = | |
1323 | 302 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]); |
2967 | 303 s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] = |
1323 | 304 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]); |
305 | |
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
|
306 skip_bits1(&s->gb); /* marker */ |
1323 | 307 }else |
308 memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */ | |
0 | 309 s->mb_intra = 1; |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
310 #ifdef HAVE_XVMC |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
311 //one 1 we memcpy blocks in xvmcvideo |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
312 if(s->avctx->xvmc_acceleration > 1){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
313 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
|
314 if(s->swap_uv){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
315 exchange_uv(s); |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
316 } |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
317 } |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
318 #endif |
0 | 319 |
1421 | 320 if (s->codec_id == CODEC_ID_MPEG2VIDEO) { |
2622 | 321 if(s->flags2 & CODEC_FLAG2_FAST){ |
322 for(i=0;i<6;i++) { | |
323 mpeg2_fast_decode_block_intra(s, s->pblocks[i], i); | |
324 } | |
325 }else{ | |
326 for(i=0;i<mb_block_count;i++) { | |
327 if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0) | |
328 return -1; | |
329 } | |
0 | 330 } |
331 } else { | |
332 for(i=0;i<6;i++) { | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
333 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
|
334 return -1; |
0 | 335 } |
336 } | |
337 } 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
|
338 if (mb_type & MB_TYPE_ZERO_MV){ |
1655 | 339 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
|
340 |
5437 | 341 s->mv_dir = MV_DIR_FORWARD; |
342 if(s->picture_structure == PICT_FRAME){ | |
343 if(!s->frame_pred_frame_dct) | |
344 s->interlaced_dct = get_bits1(&s->gb); | |
345 s->mv_type = MV_TYPE_16X16; | |
346 }else{ | |
347 s->mv_type = MV_TYPE_FIELD; | |
348 mb_type |= MB_TYPE_INTERLACED; | |
349 s->field_select[0][0]= s->picture_structure - 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
|
350 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
351 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
352 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
|
353 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
|
354 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
355 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
|
356 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
|
357 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
|
358 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
|
359 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
|
360 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
|
361 }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
|
362 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
|
363 //FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED |
4795 | 364 /* get additional motion vector type */ |
2967 | 365 if (s->frame_pred_frame_dct) |
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
|
366 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
|
367 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
|
368 motion_type = get_bits(&s->gb, 2); |
5438 | 369 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type)) |
370 s->interlaced_dct = get_bits1(&s->gb); | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
371 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
372 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
373 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
|
374 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
|
375 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
376 /* motion vectors */ |
5447 | 377 s->mv_dir= (mb_type>>13)&3; |
5441 | 378 dprintf(s->avctx, "motion_type=%d\n", motion_type); |
379 switch(motion_type) { | |
380 case MT_FRAME: /* or MT_16X8 */ | |
5443
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
381 if (s->picture_structure == PICT_FRAME) { |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
382 mb_type |= MB_TYPE_16x16; |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
383 s->mv_type = MV_TYPE_16X16; |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
384 for(i=0;i<2;i++) { |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
385 if (USES_LIST(mb_type, i)) { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
386 /* MT_FRAME */ |
2967 | 387 s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] = |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
388 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]); |
2967 | 389 s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][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
|
390 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
|
391 /* 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
|
392 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
|
393 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
|
394 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
|
395 } |
5443
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
396 } |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
397 } |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
398 } else { |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
399 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
400 s->mv_type = MV_TYPE_16X8; |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
401 for(i=0;i<2;i++) { |
40c87c0f754b
exchange for() and if() order in the MT_FRAME case
michael
parents:
5441
diff
changeset
|
402 if (USES_LIST(mb_type, i)) { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
403 /* 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
|
404 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
|
405 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
|
406 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
|
407 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
|
408 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
|
409 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
|
410 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
|
411 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
412 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
413 } |
5441 | 414 } |
415 } | |
416 break; | |
417 case MT_FIELD: | |
418 s->mv_type = MV_TYPE_FIELD; | |
5444 | 419 if (s->picture_structure == PICT_FRAME) { |
420 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; | |
421 for(i=0;i<2;i++) { | |
422 if (USES_LIST(mb_type, i)) { | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
423 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
|
424 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
|
425 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
|
426 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
|
427 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
|
428 s->mv[i][j][0] = val; |
4652 | 429 dprintf(s->avctx, "fmx=%d\n", val); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
430 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
|
431 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
|
432 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
|
433 s->mv[i][j][1] = val; |
4652 | 434 dprintf(s->avctx, "fmy=%d\n", val); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
435 } |
5444 | 436 } |
437 } | |
438 } else { | |
439 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED; | |
440 for(i=0;i<2;i++) { | |
441 if (USES_LIST(mb_type, i)) { | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
442 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
|
443 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
|
444 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
|
445 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
|
446 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
|
447 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
|
448 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
|
449 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
450 } |
5441 | 451 } |
452 } | |
453 break; | |
454 case MT_DMV: | |
455 s->mv_type = MV_TYPE_DMV; | |
456 for(i=0;i<2;i++) { | |
457 if (USES_LIST(mb_type, i)) { | |
458 int dmx, dmy, mx, my, m; | |
459 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], | |
460 s->last_mv[i][0][0]); | |
461 s->last_mv[i][0][0] = mx; | |
462 s->last_mv[i][1][0] = mx; | |
463 dmx = get_dmv(s); | |
464 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], | |
465 s->last_mv[i][0][1] >> 1); | |
466 dmy = get_dmv(s); | |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
467 |
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
468 |
5441 | 469 s->last_mv[i][0][1] = my<<1; |
470 s->last_mv[i][1][1] = my<<1; | |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
471 |
5441 | 472 s->mv[i][0][0] = mx; |
473 s->mv[i][0][1] = my; | |
474 s->mv[i][1][0] = mx;//not used | |
475 s->mv[i][1][1] = my;//not used | |
1326
6cdd3b8f4fd3
DMV support patch by ("Ivan Kalvachev" <ivan at cacad dot com>)
michaelni
parents:
1325
diff
changeset
|
476 |
5441 | 477 if (s->picture_structure == PICT_FRAME) { |
478 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
|
479 |
5441 | 480 //m = 1 + 2 * s->top_field_first; |
481 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
|
482 |
5441 | 483 /* top -> top pred */ |
484 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx; | |
485 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1; | |
486 m = 4 - m; | |
487 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx; | |
488 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1; | |
489 } else { | |
490 mb_type |= MB_TYPE_16x16; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
491 |
5441 | 492 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx; |
493 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy; | |
494 if(s->picture_structure == PICT_TOP_FIELD) | |
495 s->mv[i][2][1]--; | |
496 else | |
497 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
|
498 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
499 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
500 } |
5441 | 501 break; |
502 default: | |
503 av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y); | |
504 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
|
505 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
506 } |
2967 | 507 |
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
|
508 s->mb_intra = 0; |
2624 | 509 if (HAS_CBP(mb_type)) { |
510 s->dsp.clear_blocks(s->block[0]); | |
2967 | 511 |
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
|
512 cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1); |
2076 | 513 if(mb_block_count > 6){ |
2979 | 514 cbp<<= mb_block_count-6; |
515 cbp |= get_bits(&s->gb, mb_block_count-6); | |
5440 | 516 s->dsp.clear_blocks(s->block[6]); |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1841
diff
changeset
|
517 } |
5439
f1db308c277b
reorder if() so that the condition can be simplified
michael
parents:
5438
diff
changeset
|
518 if (cbp <= 0){ |
f1db308c277b
reorder if() so that the condition can be simplified
michael
parents:
5438
diff
changeset
|
519 av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y); |
f1db308c277b
reorder if() so that the condition can be simplified
michael
parents:
5438
diff
changeset
|
520 return -1; |
f1db308c277b
reorder if() so that the condition can be simplified
michael
parents:
5438
diff
changeset
|
521 } |
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
|
522 |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
523 #ifdef HAVE_XVMC |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
524 //on 1 we memcpy blocks in xvmcvideo |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
525 if(s->avctx->xvmc_acceleration > 1){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
526 XVMC_pack_pblocks(s,cbp); |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
527 if(s->swap_uv){ |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
528 exchange_uv(s); |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
529 } |
2967 | 530 } |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
531 #endif |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
532 |
1421 | 533 if (s->codec_id == CODEC_ID_MPEG2VIDEO) { |
2201 | 534 if(s->flags2 & CODEC_FLAG2_FAST){ |
535 for(i=0;i<6;i++) { | |
536 if(cbp & 32) { | |
537 mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i); | |
538 } else { | |
539 s->block_last_index[i] = -1; | |
540 } | |
541 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
|
542 } |
2201 | 543 }else{ |
544 cbp<<= 12-mb_block_count; | |
2967 | 545 |
2201 | 546 for(i=0;i<mb_block_count;i++) { |
547 if ( cbp & (1<<11) ) { | |
548 if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0) | |
549 return -1; | |
550 } else { | |
551 s->block_last_index[i] = -1; | |
552 } | |
553 cbp+=cbp; | |
554 } | |
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
|
555 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
556 } else { |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
557 if(s->flags2 & CODEC_FLAG2_FAST){ |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
558 for(i=0;i<6;i++) { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
559 if (cbp & 32) { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
560 mpeg1_fast_decode_block_inter(s, s->pblocks[i], i); |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
561 } else { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
562 s->block_last_index[i] = -1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
563 } |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
564 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
|
565 } |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
566 }else{ |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
567 for(i=0;i<6;i++) { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
568 if (cbp & 32) { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
569 if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0) |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
570 return -1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
571 } else { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
572 s->block_last_index[i] = -1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
573 } |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
574 cbp+=cbp; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
575 } |
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
|
576 } |
711 | 577 } |
578 }else{ | |
2947
18d47c6673f7
Mark all 12 block unused when there are no coded blocks
iive
parents:
2834
diff
changeset
|
579 for(i=0;i<12;i++) |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
580 s->block_last_index[i] = -1; |
0 | 581 } |
582 } | |
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
|
583 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
584 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
|
585 |
0 | 586 return 0; |
587 } | |
588 | |
589 /* as h263, but only 17 codes */ | |
590 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred) | |
591 { | |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
592 int code, sign, val, l, shift; |
0 | 593 |
545 | 594 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
|
595 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
|
596 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
|
597 } |
0 | 598 if (code < 0) { |
599 return 0xffff; | |
600 } | |
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
|
601 |
21 | 602 sign = get_bits1(&s->gb); |
0 | 603 shift = fcode - 1; |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
604 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
605 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
606 val = (val - 1) << shift; |
0 | 607 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
|
608 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
609 } |
0 | 610 if (sign) |
611 val = -val; | |
612 val += pred; | |
2967 | 613 |
0 | 614 /* modulo decoding */ |
2093 | 615 l= INT_BIT - 5 - shift; |
616 val = (val<<l)>>l; | |
0 | 617 return val; |
618 } | |
619 | |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
620 static inline int decode_dc(GetBitContext *gb, int component) |
0 | 621 { |
622 int code, diff; | |
623 | |
624 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
|
625 code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2); |
0 | 626 } 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
|
627 code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2); |
0 | 628 } |
568 | 629 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
630 av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n"); |
0 | 631 return 0xffff; |
568 | 632 } |
0 | 633 if (code == 0) { |
634 diff = 0; | |
635 } 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
|
636 diff = get_xbits(gb, code); |
0 | 637 } |
638 return diff; | |
639 } | |
640 | |
2967 | 641 static inline int mpeg1_decode_block_intra(MpegEncContext *s, |
642 DCTELEM *block, | |
0 | 643 int n) |
644 { | |
645 int level, dc, diff, i, j, run; | |
711 | 646 int component; |
5210 | 647 RLTable *rl = &ff_rl_mpeg1; |
1064 | 648 uint8_t * const scantable= s->intra_scantable.permutated; |
649 const uint16_t *quant_matrix= s->intra_matrix; | |
711 | 650 const int qscale= s->qscale; |
0 | 651 |
711 | 652 /* DC coef */ |
653 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
|
654 diff = decode_dc(&s->gb, component); |
711 | 655 if (diff >= 0xffff) |
656 return -1; | |
657 dc = s->last_dc[component]; | |
658 dc += diff; | |
659 s->last_dc[component] = dc; | |
660 block[0] = dc<<3; | |
4652 | 661 dprintf(s->avctx, "dc=%d diff=%d\n", dc, diff); |
711 | 662 i = 0; |
663 { | |
2967 | 664 OPEN_READER(re, &s->gb); |
711 | 665 /* now quantify & encode AC coefs */ |
666 for(;;) { | |
667 UPDATE_CACHE(re, &s->gb); | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2591
diff
changeset
|
668 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); |
2967 | 669 |
711 | 670 if(level == 127){ |
671 break; | |
672 } else if(level != 0) { | |
673 i += run; | |
674 j = scantable[i]; | |
1728 | 675 level= (level*qscale*quant_matrix[j])>>4; |
711 | 676 level= (level-1)|1; |
677 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
678 LAST_SKIP_BITS(re, &s->gb, 1); | |
679 } else { | |
680 /* escape */ | |
681 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
682 UPDATE_CACHE(re, &s->gb); | |
683 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8); | |
684 if (level == -128) { | |
685 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8); | |
686 } else if (level == 0) { | |
687 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8); | |
688 } | |
689 i += run; | |
690 j = scantable[i]; | |
691 if(level<0){ | |
692 level= -level; | |
1728 | 693 level= (level*qscale*quant_matrix[j])>>4; |
711 | 694 level= (level-1)|1; |
695 level= -level; | |
696 }else{ | |
1728 | 697 level= (level*qscale*quant_matrix[j])>>4; |
711 | 698 level= (level-1)|1; |
699 } | |
700 } | |
701 if (i > 63){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
702 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
711 | 703 return -1; |
704 } | |
705 | |
706 block[j] = level; | |
707 } | |
708 CLOSE_READER(re, &s->gb); | |
709 } | |
710 s->block_last_index[n] = i; | |
711 return 0; | |
712 } | |
713 | |
2967 | 714 static inline int mpeg1_decode_block_inter(MpegEncContext *s, |
715 DCTELEM *block, | |
711 | 716 int n) |
717 { | |
718 int level, i, j, run; | |
5210 | 719 RLTable *rl = &ff_rl_mpeg1; |
1064 | 720 uint8_t * const scantable= s->intra_scantable.permutated; |
721 const uint16_t *quant_matrix= s->inter_matrix; | |
711 | 722 const int qscale= s->qscale; |
723 | |
724 { | |
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
|
725 OPEN_READER(re, &s->gb); |
711 | 726 i = -1; |
0 | 727 /* 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
|
728 UPDATE_CACHE(re, &s->gb); |
2617 | 729 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) { |
1728 | 730 level= (3*qscale*quant_matrix[0])>>5; |
711 | 731 level= (level-1)|1; |
2617 | 732 if(GET_CACHE(re, &s->gb)&0x40000000) |
711 | 733 level= -level; |
714 | 734 block[0] = level; |
711 | 735 i++; |
2617 | 736 SKIP_BITS(re, &s->gb, 2); |
737 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) | |
738 goto end; | |
0 | 739 } |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
740 #if MIN_CACHE_BITS < 19 |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
741 UPDATE_CACHE(re, &s->gb); |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
742 #endif |
711 | 743 /* now quantify & encode AC coefs */ |
744 for(;;) { | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2591
diff
changeset
|
745 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); |
2967 | 746 |
2617 | 747 if(level != 0) { |
711 | 748 i += run; |
749 j = scantable[i]; | |
1728 | 750 level= ((level*2+1)*qscale*quant_matrix[j])>>5; |
711 | 751 level= (level-1)|1; |
752 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
2617 | 753 SKIP_BITS(re, &s->gb, 1); |
711 | 754 } else { |
755 /* escape */ | |
756 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
757 UPDATE_CACHE(re, &s->gb); | |
758 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8); | |
759 if (level == -128) { | |
2617 | 760 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8); |
711 | 761 } else if (level == 0) { |
2617 | 762 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8); |
711 | 763 } |
764 i += run; | |
765 j = scantable[i]; | |
766 if(level<0){ | |
767 level= -level; | |
1728 | 768 level= ((level*2+1)*qscale*quant_matrix[j])>>5; |
711 | 769 level= (level-1)|1; |
770 level= -level; | |
771 }else{ | |
1728 | 772 level= ((level*2+1)*qscale*quant_matrix[j])>>5; |
711 | 773 level= (level-1)|1; |
774 } | |
775 } | |
776 if (i > 63){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
777 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
711 | 778 return -1; |
779 } | |
0 | 780 |
711 | 781 block[j] = level; |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
782 #if MIN_CACHE_BITS < 19 |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
783 UPDATE_CACHE(re, &s->gb); |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
784 #endif |
2617 | 785 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) |
786 break; | |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
787 #if MIN_CACHE_BITS >= 19 |
2617 | 788 UPDATE_CACHE(re, &s->gb); |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
789 #endif |
0 | 790 } |
2617 | 791 end: |
792 LAST_SKIP_BITS(re, &s->gb, 2); | |
711 | 793 CLOSE_READER(re, &s->gb); |
0 | 794 } |
711 | 795 s->block_last_index[n] = i; |
0 | 796 return 0; |
797 } | |
798 | |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
799 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
|
800 { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
801 int level, i, j, run; |
5210 | 802 RLTable *rl = &ff_rl_mpeg1; |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
803 uint8_t * const scantable= s->intra_scantable.permutated; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
804 const int qscale= s->qscale; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
805 |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
806 { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
807 OPEN_READER(re, &s->gb); |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
808 i = -1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
809 /* 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
|
810 UPDATE_CACHE(re, &s->gb); |
2617 | 811 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) { |
2203 | 812 level= (3*qscale)>>1; |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
813 level= (level-1)|1; |
2617 | 814 if(GET_CACHE(re, &s->gb)&0x40000000) |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
815 level= -level; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
816 block[0] = level; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
817 i++; |
2617 | 818 SKIP_BITS(re, &s->gb, 2); |
819 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) | |
820 goto end; | |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
821 } |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
822 #if MIN_CACHE_BITS < 19 |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
823 UPDATE_CACHE(re, &s->gb); |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
824 #endif |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
825 |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
826 /* now quantify & encode AC coefs */ |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
827 for(;;) { |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2591
diff
changeset
|
828 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); |
2967 | 829 |
2617 | 830 if(level != 0) { |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
831 i += run; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
832 j = scantable[i]; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
833 level= ((level*2+1)*qscale)>>1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
834 level= (level-1)|1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
835 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); |
2617 | 836 SKIP_BITS(re, &s->gb, 1); |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
837 } else { |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
838 /* escape */ |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
839 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
|
840 UPDATE_CACHE(re, &s->gb); |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
841 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
|
842 if (level == -128) { |
2617 | 843 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8); |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
844 } else if (level == 0) { |
2617 | 845 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8); |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
846 } |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
847 i += run; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
848 j = scantable[i]; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
849 if(level<0){ |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
850 level= -level; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
851 level= ((level*2+1)*qscale)>>1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
852 level= (level-1)|1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
853 level= -level; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
854 }else{ |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
855 level= ((level*2+1)*qscale)>>1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
856 level= (level-1)|1; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
857 } |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
858 } |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
859 |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
860 block[j] = level; |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
861 #if MIN_CACHE_BITS < 19 |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
862 UPDATE_CACHE(re, &s->gb); |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
863 #endif |
2617 | 864 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) |
865 break; | |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
866 #if MIN_CACHE_BITS >= 19 |
2617 | 867 UPDATE_CACHE(re, &s->gb); |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
868 #endif |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
869 } |
2617 | 870 end: |
871 LAST_SKIP_BITS(re, &s->gb, 2); | |
2202
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
872 CLOSE_READER(re, &s->gb); |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
873 } |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
874 s->block_last_index[n] = i; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
875 return 0; |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
876 } |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
877 |
8079b177ff5c
optional non spec compliant optimizations for mpeg1
michael
parents:
2201
diff
changeset
|
878 |
2967 | 879 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, |
880 DCTELEM *block, | |
714 | 881 int n) |
0 | 882 { |
883 int level, i, j, run; | |
5210 | 884 RLTable *rl = &ff_rl_mpeg1; |
1064 | 885 uint8_t * const scantable= s->intra_scantable.permutated; |
886 const uint16_t *quant_matrix; | |
714 | 887 const int qscale= s->qscale; |
0 | 888 int mismatch; |
889 | |
890 mismatch = 1; | |
891 | |
892 { | |
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
|
893 OPEN_READER(re, &s->gb); |
714 | 894 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
|
895 if (n < 4) |
714 | 896 quant_matrix = s->inter_matrix; |
0 | 897 else |
714 | 898 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
|
899 |
0 | 900 /* 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
|
901 UPDATE_CACHE(re, &s->gb); |
2617 | 902 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) { |
714 | 903 level= (3*qscale*quant_matrix[0])>>5; |
2617 | 904 if(GET_CACHE(re, &s->gb)&0x40000000) |
714 | 905 level= -level; |
906 block[0] = level; | |
907 mismatch ^= level; | |
908 i++; | |
2617 | 909 SKIP_BITS(re, &s->gb, 2); |
910 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) | |
911 goto end; | |
714 | 912 } |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
913 #if MIN_CACHE_BITS < 19 |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
914 UPDATE_CACHE(re, &s->gb); |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
915 #endif |
714 | 916 |
917 /* now quantify & encode AC coefs */ | |
918 for(;;) { | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2591
diff
changeset
|
919 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); |
2967 | 920 |
2617 | 921 if(level != 0) { |
714 | 922 i += run; |
923 j = scantable[i]; | |
924 level= ((level*2+1)*qscale*quant_matrix[j])>>5; | |
925 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
2617 | 926 SKIP_BITS(re, &s->gb, 1); |
714 | 927 } else { |
928 /* escape */ | |
929 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
930 UPDATE_CACHE(re, &s->gb); | |
931 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); | |
932 | |
933 i += run; | |
934 j = scantable[i]; | |
935 if(level<0){ | |
936 level= ((-level*2+1)*qscale*quant_matrix[j])>>5; | |
937 level= -level; | |
938 }else{ | |
939 level= ((level*2+1)*qscale*quant_matrix[j])>>5; | |
940 } | |
941 } | |
942 if (i > 63){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
943 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
714 | 944 return -1; |
945 } | |
2967 | 946 |
714 | 947 mismatch ^= level; |
948 block[j] = level; | |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
949 #if MIN_CACHE_BITS < 19 |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
950 UPDATE_CACHE(re, &s->gb); |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
951 #endif |
2617 | 952 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) |
953 break; | |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
954 #if MIN_CACHE_BITS >= 19 |
2617 | 955 UPDATE_CACHE(re, &s->gb); |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
956 #endif |
0 | 957 } |
2617 | 958 end: |
959 LAST_SKIP_BITS(re, &s->gb, 2); | |
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
|
960 CLOSE_READER(re, &s->gb); |
0 | 961 } |
962 block[63] ^= (mismatch & 1); | |
2967 | 963 |
0 | 964 s->block_last_index[n] = i; |
965 return 0; | |
966 } | |
967 | |
2967 | 968 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, |
969 DCTELEM *block, | |
2201 | 970 int n) |
971 { | |
972 int level, i, j, run; | |
5210 | 973 RLTable *rl = &ff_rl_mpeg1; |
2201 | 974 uint8_t * const scantable= s->intra_scantable.permutated; |
975 const int qscale= s->qscale; | |
976 OPEN_READER(re, &s->gb); | |
977 i = -1; | |
978 | |
979 /* special case for the first coef. no need to add a second vlc table */ | |
980 UPDATE_CACHE(re, &s->gb); | |
2617 | 981 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) { |
2201 | 982 level= (3*qscale)>>1; |
2617 | 983 if(GET_CACHE(re, &s->gb)&0x40000000) |
2201 | 984 level= -level; |
985 block[0] = level; | |
986 i++; | |
2617 | 987 SKIP_BITS(re, &s->gb, 2); |
988 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) | |
989 goto end; | |
2201 | 990 } |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
991 #if MIN_CACHE_BITS < 19 |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
992 UPDATE_CACHE(re, &s->gb); |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
993 #endif |
2201 | 994 |
995 /* now quantify & encode AC coefs */ | |
996 for(;;) { | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2591
diff
changeset
|
997 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); |
2967 | 998 |
2617 | 999 if(level != 0) { |
2201 | 1000 i += run; |
1001 j = scantable[i]; | |
1002 level= ((level*2+1)*qscale)>>1; | |
1003 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
2617 | 1004 SKIP_BITS(re, &s->gb, 1); |
2201 | 1005 } else { |
1006 /* escape */ | |
1007 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
1008 UPDATE_CACHE(re, &s->gb); | |
1009 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); | |
1010 | |
1011 i += run; | |
1012 j = scantable[i]; | |
1013 if(level<0){ | |
1014 level= ((-level*2+1)*qscale)>>1; | |
1015 level= -level; | |
1016 }else{ | |
1017 level= ((level*2+1)*qscale)>>1; | |
1018 } | |
1019 } | |
2967 | 1020 |
2201 | 1021 block[j] = level; |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
1022 #if MIN_CACHE_BITS < 19 |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
1023 UPDATE_CACHE(re, &s->gb); |
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
1024 #endif |
2617 | 1025 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF) |
1026 break; | |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
1027 #if MIN_CACHE_BITS >=19 |
2617 | 1028 UPDATE_CACHE(re, &s->gb); |
5458
ebe106e3339e
Make MPEG-1/2 decoder work with the libmpeg2-style bitstream reader.
michael
parents:
5449
diff
changeset
|
1029 #endif |
2201 | 1030 } |
2617 | 1031 end: |
2967 | 1032 LAST_SKIP_BITS(re, &s->gb, 2); |
2201 | 1033 CLOSE_READER(re, &s->gb); |
1034 s->block_last_index[n] = i; | |
1035 return 0; | |
1036 } | |
1037 | |
1038 | |
2967 | 1039 static inline int mpeg2_decode_block_intra(MpegEncContext *s, |
1040 DCTELEM *block, | |
714 | 1041 int n) |
0 | 1042 { |
1043 int level, dc, diff, i, j, run; | |
714 | 1044 int component; |
0 | 1045 RLTable *rl; |
1064 | 1046 uint8_t * const scantable= s->intra_scantable.permutated; |
1047 const uint16_t *quant_matrix; | |
714 | 1048 const int qscale= s->qscale; |
0 | 1049 int mismatch; |
1050 | |
1051 /* DC coef */ | |
714 | 1052 if (n < 4){ |
1053 quant_matrix = s->intra_matrix; | |
2967 | 1054 component = 0; |
714 | 1055 }else{ |
1056 quant_matrix = s->chroma_intra_matrix; | |
1848
c72589baee53
initial chroma_format changes,xvmc tweaks and codec_cap
iive
parents:
1841
diff
changeset
|
1057 component = (n&1) + 1; |
714 | 1058 } |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
1059 diff = decode_dc(&s->gb, component); |
0 | 1060 if (diff >= 0xffff) |
1061 return -1; | |
1062 dc = s->last_dc[component]; | |
1063 dc += diff; | |
1064 s->last_dc[component] = dc; | |
1065 block[0] = dc << (3 - s->intra_dc_precision); | |
4652 | 1066 dprintf(s->avctx, "dc=%d\n", block[0]); |
58
0e0a24def67a
fixed last zero mv for field - fixed mismatch handling for intra coefs
glantau
parents:
54
diff
changeset
|
1067 mismatch = block[0] ^ 1; |
714 | 1068 i = 0; |
0 | 1069 if (s->intra_vlc_format) |
5210 | 1070 rl = &ff_rl_mpeg2; |
0 | 1071 else |
5210 | 1072 rl = &ff_rl_mpeg1; |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1073 |
714 | 1074 { |
2967 | 1075 OPEN_READER(re, &s->gb); |
714 | 1076 /* now quantify & encode AC coefs */ |
1077 for(;;) { | |
1078 UPDATE_CACHE(re, &s->gb); | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2591
diff
changeset
|
1079 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); |
2967 | 1080 |
714 | 1081 if(level == 127){ |
1082 break; | |
1083 } else if(level != 0) { | |
1084 i += run; | |
1085 j = scantable[i]; | |
1086 level= (level*qscale*quant_matrix[j])>>4; | |
1087 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1088 LAST_SKIP_BITS(re, &s->gb, 1); | |
1089 } else { | |
1090 /* escape */ | |
1091 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
1092 UPDATE_CACHE(re, &s->gb); | |
1093 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); | |
1094 i += run; | |
1095 j = scantable[i]; | |
1096 if(level<0){ | |
1097 level= (-level*qscale*quant_matrix[j])>>4; | |
1098 level= -level; | |
1099 }else{ | |
1100 level= (level*qscale*quant_matrix[j])>>4; | |
1101 } | |
1102 } | |
1103 if (i > 63){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1104 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
714 | 1105 return -1; |
1106 } | |
2967 | 1107 |
714 | 1108 mismatch^= level; |
1109 block[j] = level; | |
568 | 1110 } |
714 | 1111 CLOSE_READER(re, &s->gb); |
0 | 1112 } |
714 | 1113 block[63]^= mismatch&1; |
2967 | 1114 |
0 | 1115 s->block_last_index[n] = i; |
1116 return 0; | |
1117 } | |
1118 | |
2967 | 1119 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, |
1120 DCTELEM *block, | |
2622 | 1121 int n) |
1122 { | |
1123 int level, dc, diff, j, run; | |
1124 int component; | |
1125 RLTable *rl; | |
1126 uint8_t * scantable= s->intra_scantable.permutated; | |
1127 const uint16_t *quant_matrix; | |
1128 const int qscale= s->qscale; | |
1129 | |
1130 /* DC coef */ | |
1131 if (n < 4){ | |
1132 quant_matrix = s->intra_matrix; | |
2967 | 1133 component = 0; |
2622 | 1134 }else{ |
1135 quant_matrix = s->chroma_intra_matrix; | |
1136 component = (n&1) + 1; | |
1137 } | |
1138 diff = decode_dc(&s->gb, component); | |
1139 if (diff >= 0xffff) | |
1140 return -1; | |
1141 dc = s->last_dc[component]; | |
1142 dc += diff; | |
1143 s->last_dc[component] = dc; | |
1144 block[0] = dc << (3 - s->intra_dc_precision); | |
1145 if (s->intra_vlc_format) | |
5210 | 1146 rl = &ff_rl_mpeg2; |
2622 | 1147 else |
5210 | 1148 rl = &ff_rl_mpeg1; |
2622 | 1149 |
1150 { | |
2967 | 1151 OPEN_READER(re, &s->gb); |
2622 | 1152 /* now quantify & encode AC coefs */ |
1153 for(;;) { | |
1154 UPDATE_CACHE(re, &s->gb); | |
1155 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); | |
2967 | 1156 |
2622 | 1157 if(level == 127){ |
1158 break; | |
1159 } else if(level != 0) { | |
1160 scantable += run; | |
1161 j = *scantable; | |
1162 level= (level*qscale*quant_matrix[j])>>4; | |
1163 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1164 LAST_SKIP_BITS(re, &s->gb, 1); | |
1165 } else { | |
1166 /* escape */ | |
1167 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); | |
1168 UPDATE_CACHE(re, &s->gb); | |
1169 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12); | |
1170 scantable += run; | |
1171 j = *scantable; | |
1172 if(level<0){ | |
1173 level= (-level*qscale*quant_matrix[j])>>4; | |
1174 level= -level; | |
1175 }else{ | |
1176 level= (level*qscale*quant_matrix[j])>>4; | |
1177 } | |
1178 } | |
2967 | 1179 |
2622 | 1180 block[j] = level; |
1181 } | |
1182 CLOSE_READER(re, &s->gb); | |
1183 } | |
2967 | 1184 |
2622 | 1185 s->block_last_index[n] = scantable - s->intra_scantable.permutated; |
1186 return 0; | |
1187 } | |
1188 | |
0 | 1189 typedef struct Mpeg1Context { |
1190 MpegEncContext mpeg_enc_ctx; | |
1191 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
|
1192 int repeat_field; /* true if we must repeat the field */ |
1546 | 1193 AVPanScan pan_scan; /** some temporary storage for the panscan */ |
1827 | 1194 int slice_count; |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1195 int swap_uv;//indicate VCR2 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1196 int save_aspect_info; |
4888
185f5e4feb72
make mpeg decoder handle mid-stream changes in resolution
benoit
parents:
4795
diff
changeset
|
1197 int save_width, save_height; |
2219 | 1198 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
|
1199 |
0 | 1200 } Mpeg1Context; |
1201 | |
1202 static int mpeg_decode_init(AVCodecContext *avctx) | |
1203 { | |
1204 Mpeg1Context *s = avctx->priv_data; | |
1892 | 1205 MpegEncContext *s2 = &s->mpeg_enc_ctx; |
1990 | 1206 int i; |
2967 | 1207 |
1990 | 1208 //we need some parmutation to store |
1209 //matrixes, until MPV_common_init() | |
2967 | 1210 //set the real permutatuon |
1990 | 1211 for(i=0;i<64;i++) |
1212 s2->dsp.idct_permutation[i]=i; | |
1213 | |
1892 | 1214 MPV_decode_defaults(s2); |
2967 | 1215 |
1732
f716b8f47d98
uninitalized variables fix by (Gildas Bazin <gbazin at altern dot org>)
michael
parents:
1728
diff
changeset
|
1216 s->mpeg_enc_ctx.avctx= avctx; |
558 | 1217 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
|
1218 s->mpeg_enc_ctx.flags2= avctx->flags2; |
5210 | 1219 ff_mpeg12_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
|
1220 init_vlcs(); |
0 | 1221 |
1222 s->mpeg_enc_ctx_allocated = 0; | |
1223 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
|
1224 s->repeat_field = 0; |
344 | 1225 s->mpeg_enc_ctx.codec_id= avctx->codec->id; |
0 | 1226 return 0; |
1227 } | |
1228 | |
2967 | 1229 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm, |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1230 const uint8_t *new_perm){ |
2219 | 1231 uint16_t temp_matrix[64]; |
1232 int i; | |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1233 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1234 memcpy(temp_matrix,matrix,64*sizeof(uint16_t)); |
2967 | 1235 |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1236 for(i=0;i<64;i++){ |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1237 matrix[new_perm[i]] = temp_matrix[old_perm[i]]; |
2967 | 1238 } |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1239 } |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1240 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1241 //Call this function when we know all parameters |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1242 //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
|
1243 static int mpeg_decode_postinit(AVCodecContext *avctx){ |
2219 | 1244 Mpeg1Context *s1 = avctx->priv_data; |
1245 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
1246 uint8_t old_permutation[64]; | |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1247 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1248 if ( |
2979 | 1249 (s1->mpeg_enc_ctx_allocated == 0)|| |
2270 | 1250 avctx->coded_width != s->width || |
1251 avctx->coded_height != s->height|| | |
4888
185f5e4feb72
make mpeg decoder handle mid-stream changes in resolution
benoit
parents:
4795
diff
changeset
|
1252 s1->save_width != s->width || |
185f5e4feb72
make mpeg decoder handle mid-stream changes in resolution
benoit
parents:
4795
diff
changeset
|
1253 s1->save_height != s->height || |
2590 | 1254 s1->save_aspect_info != s->aspect_ratio_info|| |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1255 0) |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1256 { |
2967 | 1257 |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1258 if (s1->mpeg_enc_ctx_allocated) { |
2681 | 1259 ParseContext pc= s->parse_context; |
1260 s->parse_context.buffer=0; | |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1261 MPV_common_end(s); |
2681 | 1262 s->parse_context= pc; |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1263 } |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1264 |
2979 | 1265 if( (s->width == 0 )||(s->height == 0)) |
1266 return -2; | |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1267 |
2270 | 1268 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
|
1269 avctx->bit_rate = s->bit_rate; |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1270 s1->save_aspect_info = s->aspect_ratio_info; |
4888
185f5e4feb72
make mpeg decoder handle mid-stream changes in resolution
benoit
parents:
4795
diff
changeset
|
1271 s1->save_width = s->width; |
185f5e4feb72
make mpeg decoder handle mid-stream changes in resolution
benoit
parents:
4795
diff
changeset
|
1272 s1->save_height = s->height; |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1273 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1274 //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
|
1275 //that behave like P frames |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1276 avctx->has_b_frames = !(s->low_delay); |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1277 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1278 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
|
1279 //mpeg1 fps |
3391
d60dc0a7dee6
staric frame_rate_tab -> non static ff_frame_rate_tab part of the cavs patch by (Stefan Gehrer stefan.gehrer gmx de)
michael
parents:
3309
diff
changeset
|
1280 avctx->time_base.den= ff_frame_rate_tab[s->frame_rate_index].num; |
d60dc0a7dee6
staric frame_rate_tab -> non static ff_frame_rate_tab part of the cavs patch by (Stefan Gehrer stefan.gehrer gmx de)
michael
parents:
3309
diff
changeset
|
1281 avctx->time_base.num= ff_frame_rate_tab[s->frame_rate_index].den; |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1282 //mpeg1 aspect |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1283 avctx->sample_aspect_ratio= av_d2q( |
5210 | 1284 1.0/ff_mpeg1_aspect[s->aspect_ratio_info], 255); |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1285 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1286 }else{//mpeg2 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1287 //mpeg2 fps |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1288 av_reduce( |
2967 | 1289 &s->avctx->time_base.den, |
1290 &s->avctx->time_base.num, | |
3391
d60dc0a7dee6
staric frame_rate_tab -> non static ff_frame_rate_tab part of the cavs patch by (Stefan Gehrer stefan.gehrer gmx de)
michael
parents:
3309
diff
changeset
|
1291 ff_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num, |
d60dc0a7dee6
staric frame_rate_tab -> non static ff_frame_rate_tab part of the cavs patch by (Stefan Gehrer stefan.gehrer gmx de)
michael
parents:
3309
diff
changeset
|
1292 ff_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
|
1293 1<<30); |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1294 //mpeg2 aspect |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1295 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
|
1296 if( (s1->pan_scan.width == 0 )||(s1->pan_scan.height == 0) ){ |
2967 | 1297 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
|
1298 av_div_q( |
5210 | 1299 ff_mpeg2_aspect[s->aspect_ratio_info], |
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
|
1300 (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
|
1301 ); |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1302 }else{ |
2967 | 1303 s->avctx->sample_aspect_ratio= |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1304 av_div_q( |
5210 | 1305 ff_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
|
1306 (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
|
1307 ); |
2979 | 1308 } |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1309 }else{ |
2967 | 1310 s->avctx->sample_aspect_ratio= |
5210 | 1311 ff_mpeg2_aspect[s->aspect_ratio_info]; |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1312 } |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1313 }//mpeg2 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1314 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1315 if(avctx->xvmc_acceleration){ |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1316 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
|
1317 }else{ |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1318 if(s->chroma_format < 2){ |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1319 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
|
1320 }else |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1321 if(s->chroma_format == 2){ |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1322 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
|
1323 }else |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1324 if(s->chroma_format > 2){ |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1325 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
|
1326 } |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1327 } |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1328 //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
|
1329 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
|
1330 if( avctx->idct_algo == FF_IDCT_AUTO ) |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1331 avctx->idct_algo = FF_IDCT_SIMPLE; |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1332 |
2967 | 1333 //quantization matrixes may need reordering |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1334 //if dct permutation is changed |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1335 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
|
1336 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1337 if (MPV_common_init(s) < 0) |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1338 return -2; |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1339 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1340 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
|
1341 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
|
1342 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
|
1343 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
|
1344 |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1345 s1->mpeg_enc_ctx_allocated = 1; |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1346 } |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1347 return 0; |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1348 } |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1349 |
2967 | 1350 static int mpeg1_decode_picture(AVCodecContext *avctx, |
1862 | 1351 const uint8_t *buf, int buf_size) |
0 | 1352 { |
1353 Mpeg1Context *s1 = avctx->priv_data; | |
1354 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
1697 | 1355 int ref, f_code, vbv_delay; |
0 | 1356 |
2967 | 1357 if(mpeg_decode_postinit(s->avctx) < 0) |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1358 return -2; |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1359 |
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
|
1360 init_get_bits(&s->gb, buf, buf_size*8); |
0 | 1361 |
1362 ref = get_bits(&s->gb, 10); /* temporal ref */ | |
1363 s->pict_type = get_bits(&s->gb, 3); | |
2575 | 1364 if(s->pict_type == 0 || s->pict_type > 3) |
1365 return -1; | |
872 | 1366 |
1697 | 1367 vbv_delay= get_bits(&s->gb, 16); |
0 | 1368 if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) { |
21 | 1369 s->full_pel[0] = get_bits1(&s->gb); |
0 | 1370 f_code = get_bits(&s->gb, 3); |
2786 | 1371 if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT) |
0 | 1372 return -1; |
1373 s->mpeg_f_code[0][0] = f_code; | |
1374 s->mpeg_f_code[0][1] = f_code; | |
1375 } | |
1376 if (s->pict_type == B_TYPE) { | |
21 | 1377 s->full_pel[1] = get_bits1(&s->gb); |
0 | 1378 f_code = get_bits(&s->gb, 3); |
2786 | 1379 if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT) |
0 | 1380 return -1; |
1381 s->mpeg_f_code[1][0] = f_code; | |
1382 s->mpeg_f_code[1][1] = f_code; | |
1383 } | |
903 | 1384 s->current_picture.pict_type= s->pict_type; |
1385 s->current_picture.key_frame= s->pict_type == I_TYPE; | |
2967 | 1386 |
2575 | 1387 if(avctx->debug & FF_DEBUG_PICT_INFO) |
1388 av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type); | |
2967 | 1389 |
0 | 1390 s->y_dc_scale = 8; |
1391 s->c_dc_scale = 8; | |
1392 s->first_slice = 1; | |
1393 return 0; | |
1394 } | |
1395 | |
2219 | 1396 static void mpeg_decode_sequence_extension(Mpeg1Context *s1) |
0 | 1397 { |
2219 | 1398 MpegEncContext *s= &s1->mpeg_enc_ctx; |
0 | 1399 int horiz_size_ext, vert_size_ext; |
1721 | 1400 int bit_rate_ext; |
0 | 1401 |
1421 | 1402 skip_bits(&s->gb, 1); /* profil and level esc*/ |
2167 | 1403 s->avctx->profile= get_bits(&s->gb, 3); |
1404 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
|
1405 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
|
1406 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */ |
0 | 1407 horiz_size_ext = get_bits(&s->gb, 2); |
1408 vert_size_ext = get_bits(&s->gb, 2); | |
1409 s->width |= (horiz_size_ext << 12); | |
1410 s->height |= (vert_size_ext << 12); | |
1411 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */ | |
2540 | 1412 s->bit_rate += (bit_rate_ext << 18) * 400; |
21 | 1413 skip_bits1(&s->gb); /* marker */ |
1710
4a68b20eeb2c
print vbv buffer size & bitrate when decoding with -debug 1
michael
parents:
1708
diff
changeset
|
1414 s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10; |
1346 | 1415 |
917 | 1416 s->low_delay = get_bits1(&s->gb); |
1346 | 1417 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1; |
1418 | |
2219 | 1419 s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1; |
1420 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
|
1421 |
4652 | 1422 dprintf(s->avctx, "sequence extension\n"); |
1421 | 1423 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
|
1424 s->avctx->sub_id = 2; /* indicates mpeg2 found */ |
917 | 1425 |
1421 | 1426 if(s->avctx->debug & FF_DEBUG_PICT_INFO) |
2967 | 1427 av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n", |
2167 | 1428 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
|
1429 |
0 | 1430 } |
1431 | |
1546 | 1432 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1) |
1433 { | |
1434 MpegEncContext *s= &s1->mpeg_enc_ctx; | |
1435 int color_description, w, h; | |
1436 | |
1437 skip_bits(&s->gb, 3); /* video format */ | |
1438 color_description= get_bits1(&s->gb); | |
1439 if(color_description){ | |
1440 skip_bits(&s->gb, 8); /* color primaries */ | |
1441 skip_bits(&s->gb, 8); /* transfer_characteristics */ | |
1442 skip_bits(&s->gb, 8); /* matrix_coefficients */ | |
1443 } | |
1444 w= get_bits(&s->gb, 14); | |
1445 skip_bits(&s->gb, 1); //marker | |
1446 h= get_bits(&s->gb, 14); | |
1447 skip_bits(&s->gb, 1); //marker | |
2967 | 1448 |
1546 | 1449 s1->pan_scan.width= 16*w; |
1450 s1->pan_scan.height=16*h; | |
2967 | 1451 |
1546 | 1452 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
|
1453 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h); |
1546 | 1454 } |
1455 | |
1456 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1) | |
1457 { | |
1458 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
|
1459 int i,nofco; |
1546 | 1460 |
1891
f403b3e286b3
use pan_scan to remove some weight, proper pan_scan offset reading
iive
parents:
1890
diff
changeset
|
1461 nofco = 1; |
f403b3e286b3
use pan_scan to remove some weight, proper pan_scan offset reading
iive
parents:
1890
diff
changeset
|
1462 if(s->progressive_sequence){ |
f403b3e286b3
use pan_scan to remove some weight, proper pan_scan offset reading
iive
parents:
1890
diff
changeset
|
1463 if(s->repeat_first_field){ |
2979 | 1464 nofco++; |
1465 if(s->top_field_first) | |
1466 nofco++; | |
1467 } | |
1891
f403b3e286b3
use pan_scan to remove some weight, proper pan_scan offset reading
iive
parents:
1890
diff
changeset
|
1468 }else{ |
f403b3e286b3
use pan_scan to remove some weight, proper pan_scan offset reading
iive
parents:
1890
diff
changeset
|
1469 if(s->picture_structure == PICT_FRAME){ |
f403b3e286b3
use pan_scan to remove some weight, proper pan_scan offset reading
iive
parents:
1890
diff
changeset
|
1470 nofco++; |
2979 | 1471 if(s->repeat_first_field) |
1472 nofco++; | |
1473 } | |
1891
f403b3e286b3
use pan_scan to remove some weight, proper pan_scan offset reading
iive
parents:
1890
diff
changeset
|
1474 } |
f403b3e286b3
use pan_scan to remove some weight, proper pan_scan offset reading
iive
parents:
1890
diff
changeset
|
1475 for(i=0; i<nofco; i++){ |
1546 | 1476 s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16); |
1477 skip_bits(&s->gb, 1); //marker | |
1478 s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16); | |
1479 skip_bits(&s->gb, 1); //marker | |
1480 } | |
2967 | 1481 |
1546 | 1482 if(s->avctx->debug & FF_DEBUG_PICT_INFO) |
2967 | 1483 av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n", |
1484 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1], | |
1485 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1], | |
1546 | 1486 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1] |
1487 ); | |
1488 } | |
1489 | |
0 | 1490 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s) |
1491 { | |
38
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
1492 int i, v, j; |
0 | 1493 |
4652 | 1494 dprintf(s->avctx, "matrix extension\n"); |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1495 |
21 | 1496 if (get_bits1(&s->gb)) { |
0 | 1497 for(i=0;i<64;i++) { |
1498 v = get_bits(&s->gb, 8); | |
1092 | 1499 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
|
1500 s->intra_matrix[j] = v; |
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
1501 s->chroma_intra_matrix[j] = v; |
0 | 1502 } |
1503 } | |
21 | 1504 if (get_bits1(&s->gb)) { |
0 | 1505 for(i=0;i<64;i++) { |
1506 v = get_bits(&s->gb, 8); | |
1092 | 1507 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
344 | 1508 s->inter_matrix[j] = v; |
1509 s->chroma_inter_matrix[j] = v; | |
0 | 1510 } |
1511 } | |
21 | 1512 if (get_bits1(&s->gb)) { |
0 | 1513 for(i=0;i<64;i++) { |
1514 v = get_bits(&s->gb, 8); | |
1092 | 1515 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
|
1516 s->chroma_intra_matrix[j] = v; |
0 | 1517 } |
1518 } | |
21 | 1519 if (get_bits1(&s->gb)) { |
0 | 1520 for(i=0;i<64;i++) { |
1521 v = get_bits(&s->gb, 8); | |
1092 | 1522 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
344 | 1523 s->chroma_inter_matrix[j] = v; |
0 | 1524 } |
1525 } | |
1526 } | |
1527 | |
1528 static void mpeg_decode_picture_coding_extension(MpegEncContext *s) | |
1529 { | |
1530 s->full_pel[0] = s->full_pel[1] = 0; | |
1531 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4); | |
1532 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4); | |
1533 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4); | |
1534 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4); | |
1535 s->intra_dc_precision = get_bits(&s->gb, 2); | |
1536 s->picture_structure = get_bits(&s->gb, 2); | |
21 | 1537 s->top_field_first = get_bits1(&s->gb); |
1538 s->frame_pred_frame_dct = get_bits1(&s->gb); | |
1539 s->concealment_motion_vectors = get_bits1(&s->gb); | |
1540 s->q_scale_type = get_bits1(&s->gb); | |
1541 s->intra_vlc_format = get_bits1(&s->gb); | |
1542 s->alternate_scan = get_bits1(&s->gb); | |
1543 s->repeat_first_field = get_bits1(&s->gb); | |
1544 s->chroma_420_type = get_bits1(&s->gb); | |
1545 s->progressive_frame = get_bits1(&s->gb); | |
1708 | 1546 |
4070 | 1547 if(s->picture_structure == PICT_FRAME){ |
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
|
1548 s->first_field=0; |
4070 | 1549 s->v_edge_pos= 16*s->mb_height; |
1550 }else{ | |
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
|
1551 s->first_field ^= 1; |
4070 | 1552 s->v_edge_pos= 8*s->mb_height; |
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
|
1553 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
|
1554 } |
2967 | 1555 |
715
8b3ccabfce4a
move scantable init from block-decode to header parser
michaelni
parents:
714
diff
changeset
|
1556 if(s->alternate_scan){ |
1273 | 1557 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
1558 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
|
1559 }else{ |
1273 | 1560 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
1561 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
|
1562 } |
2967 | 1563 |
0 | 1564 /* composite display not parsed */ |
4652 | 1565 dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision); |
1566 dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure); | |
1567 dprintf(s->avctx, "top field first=%d\n", s->top_field_first); | |
1568 dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field); | |
1569 dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors); | |
1570 dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format); | |
1571 dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan); | |
1572 dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct); | |
1573 dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame); | |
0 | 1574 } |
1575 | |
2967 | 1576 static void mpeg_decode_extension(AVCodecContext *avctx, |
1862 | 1577 const uint8_t *buf, int buf_size) |
0 | 1578 { |
1579 Mpeg1Context *s1 = avctx->priv_data; | |
1580 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
1581 int ext_type; | |
1582 | |
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
|
1583 init_get_bits(&s->gb, buf, buf_size*8); |
2967 | 1584 |
0 | 1585 ext_type = get_bits(&s->gb, 4); |
1586 switch(ext_type) { | |
1587 case 0x1: | |
2219 | 1588 mpeg_decode_sequence_extension(s1); |
0 | 1589 break; |
1546 | 1590 case 0x2: |
1591 mpeg_decode_sequence_display_extension(s1); | |
1592 break; | |
0 | 1593 case 0x3: |
1594 mpeg_decode_quant_matrix_extension(s); | |
1595 break; | |
1546 | 1596 case 0x7: |
1597 mpeg_decode_picture_display_extension(s1); | |
1598 break; | |
0 | 1599 case 0x8: |
1600 mpeg_decode_picture_coding_extension(s); | |
1601 break; | |
1602 } | |
1603 } | |
1604 | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1605 static void exchange_uv(MpegEncContext *s){ |
2219 | 1606 short * tmp = s->pblocks[4]; |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1607 s->pblocks[4] = s->pblocks[5]; |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1608 s->pblocks[5] = tmp; |
1380 | 1609 } |
1610 | |
1827 | 1611 static int mpeg_field_start(MpegEncContext *s){ |
1612 AVCodecContext *avctx= s->avctx; | |
1613 Mpeg1Context *s1 = (Mpeg1Context*)s; | |
826 | 1614 |
0 | 1615 /* start frame decoding */ |
1827 | 1616 if(s->first_field || s->picture_structure==PICT_FRAME){ |
771
d4cc92144266
handle direct rendering buffer allocation failure
michaelni
parents:
751
diff
changeset
|
1617 if(MPV_frame_start(s, avctx) < 0) |
1827 | 1618 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
|
1619 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
1620 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
|
1621 |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
1622 /* first check if we must repeat the frame */ |
1409 | 1623 s->current_picture_ptr->repeat_pict = 0; |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
1624 if (s->repeat_first_field) { |
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
1625 if (s->progressive_sequence) { |
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
1626 if (s->top_field_first) |
1409 | 1627 s->current_picture_ptr->repeat_pict = 4; |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
1628 else |
1409 | 1629 s->current_picture_ptr->repeat_pict = 2; |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
1630 } else if (s->progressive_frame) { |
1409 | 1631 s->current_picture_ptr->repeat_pict = 1; |
1085
9acf4b552047
move repeat_pict field from AVCodecContext -> AVFrame (closes bug #683536)
michaelni
parents:
1084
diff
changeset
|
1632 } |
2967 | 1633 } |
1546 | 1634 |
1635 *s->current_picture_ptr->pan_scan= s1->pan_scan; | |
1827 | 1636 }else{ //second field |
1138 | 1637 int i; |
2967 | 1638 |
1182
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
1639 if(!s->current_picture_ptr){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1640 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
|
1641 return -1; |
38e8b8f331cb
some checks to avoid segfaults if the decoder is feeded with junk
michaelni
parents:
1181
diff
changeset
|
1642 } |
2967 | 1643 |
1138 | 1644 for(i=0; i<4; i++){ |
1645 s->current_picture.data[i] = s->current_picture_ptr->data[i]; | |
1646 if(s->picture_structure == PICT_BOTTOM_FIELD){ | |
1647 s->current_picture.data[i] += s->current_picture_ptr->linesize[i]; | |
2967 | 1648 } |
1138 | 1649 } |
1827 | 1650 } |
1381 | 1651 #ifdef HAVE_XVMC |
1652 // MPV_frame_start will call this function too, | |
1653 // but we need to call it on every field | |
1827 | 1654 if(s->avctx->xvmc_acceleration) |
1381 | 1655 XVMC_field_start(s,avctx); |
1656 #endif | |
1827 | 1657 |
1658 return 0; | |
1659 } | |
1660 | |
1661 #define DECODE_SLICE_ERROR -1 | |
1662 #define DECODE_SLICE_OK 0 | |
0 | 1663 |
1827 | 1664 /** |
1665 * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode | |
1666 * @return DECODE_SLICE_ERROR if the slice is damaged<br> | |
1667 * DECODE_SLICE_OK if this slice is ok<br> | |
1668 */ | |
1669 static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y, | |
1862 | 1670 const uint8_t **buf, int buf_size) |
1827 | 1671 { |
1672 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
1673 AVCodecContext *avctx= s->avctx; | |
1674 const int field_pic= s->picture_structure != PICT_FRAME; | |
2256 | 1675 const int lowres= s->avctx->lowres; |
1827 | 1676 |
1677 s->resync_mb_x= | |
1678 s->resync_mb_y= -1; | |
1679 | |
1953 | 1680 if (mb_y<<field_pic >= s->mb_height){ |
1681 av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s->mb_height); | |
1827 | 1682 return -1; |
1683 } | |
2967 | 1684 |
1211 | 1685 init_get_bits(&s->gb, *buf, buf_size*8); |
0 | 1686 |
1827 | 1687 ff_mpeg1_clean_buffers(s); |
1688 s->interlaced_dct = 0; | |
1689 | |
54 | 1690 s->qscale = get_qscale(s); |
1690 | 1691 |
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
|
1692 if(s->qscale == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1693 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n"); |
1285 | 1694 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
|
1695 } |
2967 | 1696 |
0 | 1697 /* extra slice info */ |
21 | 1698 while (get_bits1(&s->gb) != 0) { |
1699 skip_bits(&s->gb, 8); | |
0 | 1700 } |
2967 | 1701 |
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
|
1702 s->mb_x=0; |
0 | 1703 |
716 | 1704 for(;;) { |
1705 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
|
1706 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1707 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n"); |
1285 | 1708 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
|
1709 } |
716 | 1710 if (code >= 33) { |
1711 if (code == 33) { | |
1712 s->mb_x += 33; | |
1713 } | |
1714 /* otherwise, stuffing, nothing to do */ | |
1715 } else { | |
1716 s->mb_x += code; | |
1717 break; | |
1718 } | |
1719 } | |
4502
ff5472c81ab8
fix segfault with lol-ffplay2.mpg (dunno if this is exploitable, probably not easily)
michael
parents:
4454
diff
changeset
|
1720 if(s->mb_x >= (unsigned)s->mb_width){ |
ff5472c81ab8
fix segfault with lol-ffplay2.mpg (dunno if this is exploitable, probably not easily)
michael
parents:
4454
diff
changeset
|
1721 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n"); |
ff5472c81ab8
fix segfault with lol-ffplay2.mpg (dunno if this is exploitable, probably not easily)
michael
parents:
4454
diff
changeset
|
1722 return -1; |
ff5472c81ab8
fix segfault with lol-ffplay2.mpg (dunno if this is exploitable, probably not easily)
michael
parents:
4454
diff
changeset
|
1723 } |
1827 | 1724 |
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
|
1725 s->resync_mb_x= s->mb_x; |
1827 | 1726 s->resync_mb_y= s->mb_y= mb_y; |
1160 | 1727 s->mb_skip_run= 0; |
1389 | 1728 ff_init_block_index(s); |
716 | 1729 |
1827 | 1730 if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) { |
1731 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
2967 | 1732 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", |
1827 | 1733 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], |
2967 | 1734 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), |
1735 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"", | |
1827 | 1736 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors, |
1737 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :""); | |
1738 } | |
2967 | 1739 } |
1740 | |
0 | 1741 for(;;) { |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1742 #ifdef HAVE_XVMC |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1743 //one 1 we memcpy blocks in xvmcvideo |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1744 if(s->avctx->xvmc_acceleration > 1) |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1745 XVMC_init_block(s);//set s->block |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1746 #endif |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
1747 |
5431 | 1748 if(mpeg_decode_mb(s, s->block) < 0) |
0 | 1749 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
|
1750 |
1692 | 1751 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
|
1752 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
|
1753 int xy = s->mb_x*2 + s->mb_y*2*wrap; |
1841 | 1754 int motion_x, motion_y, dir, i; |
1692 | 1755 if(field_pic && !s->first_field) |
1756 xy += wrap/2; | |
1757 | |
1852 | 1758 for(i=0; i<2; i++){ |
1759 for(dir=0; dir<2; dir++){ | |
1841 | 1760 if (s->mb_intra || (dir==1 && s->pict_type != B_TYPE)) { |
1761 motion_x = motion_y = 0; | |
1946 | 1762 }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){ |
1841 | 1763 motion_x = s->mv[dir][0][0]; |
1764 motion_y = s->mv[dir][0][1]; | |
1765 } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ { | |
1766 motion_x = s->mv[dir][i][0]; | |
1767 motion_y = s->mv[dir][i][1]; | |
1768 } | |
1948 | 1769 |
1841 | 1770 s->current_picture.motion_val[dir][xy ][0] = motion_x; |
1771 s->current_picture.motion_val[dir][xy ][1] = motion_y; | |
1772 s->current_picture.motion_val[dir][xy + 1][0] = motion_x; | |
1773 s->current_picture.motion_val[dir][xy + 1][1] = motion_y; | |
1948 | 1774 s->current_picture.ref_index [dir][xy ]= |
1775 s->current_picture.ref_index [dir][xy + 1]= s->field_select[dir][i]; | |
2670 | 1776 assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1); |
1841 | 1777 } |
1852 | 1778 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
|
1779 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1164
diff
changeset
|
1780 } |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1655
diff
changeset
|
1781 |
2256 | 1782 s->dest[0] += 16 >> lowres; |
5430 | 1783 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift; |
1784 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift; | |
1389 | 1785 |
716 | 1786 MPV_decode_mb(s, s->block); |
2967 | 1787 |
716 | 1788 if (++s->mb_x >= s->mb_width) { |
2261 | 1789 const int mb_size= 16>>s->avctx->lowres; |
1380 | 1790 |
2261 | 1791 ff_draw_horiz_band(s, mb_size*s->mb_y, mb_size); |
716 | 1792 |
1793 s->mb_x = 0; | |
1794 s->mb_y++; | |
1289
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
1795 |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
1796 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
|
1797 int left= s->gb.size_in_bits - get_bits_count(&s->gb); |
3287 | 1798 int is_d10= s->chroma_format==2 && s->pict_type==I_TYPE && avctx->profile==0 && avctx->level==5 |
1799 && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0 | |
1800 && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/; | |
1801 | |
1802 if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) | |
1289
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
1803 || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){ |
3287 | 1804 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23))); |
1289
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
1805 return -1; |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
1806 }else |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
1807 goto eos; |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
1808 } |
2967 | 1809 |
1389 | 1810 ff_init_block_index(s); |
716 | 1811 } |
1812 | |
1813 /* skip mb handling */ | |
1160 | 1814 if (s->mb_skip_run == -1) { |
716 | 1815 /* read again increment */ |
1160 | 1816 s->mb_skip_run = 0; |
716 | 1817 for(;;) { |
1818 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
|
1819 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1587
diff
changeset
|
1820 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n"); |
1181 | 1821 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
|
1822 } |
716 | 1823 if (code >= 33) { |
1824 if (code == 33) { | |
1160 | 1825 s->mb_skip_run += 33; |
1181 | 1826 }else if(code == 35){ |
1827 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
|
1828 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n"); |
1181 | 1829 return -1; |
1830 } | |
1831 goto eos; /* end of slice */ | |
716 | 1832 } |
1833 /* otherwise, stuffing, nothing to do */ | |
1834 } else { | |
1160 | 1835 s->mb_skip_run += code; |
716 | 1836 break; |
1837 } | |
1838 } | |
5432
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1839 if(s->mb_skip_run){ |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1840 int i; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1841 if(s->pict_type == I_TYPE){ |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1842 av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y); |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1843 return -1; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1844 } |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1845 |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1846 /* skip mb */ |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1847 s->mb_intra = 0; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1848 for(i=0;i<12;i++) |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1849 s->block_last_index[i] = -1; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1850 if(s->picture_structure == PICT_FRAME) |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1851 s->mv_type = MV_TYPE_16X16; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1852 else |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1853 s->mv_type = MV_TYPE_FIELD; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1854 if (s->pict_type == P_TYPE) { |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1855 /* if P type, zero motion vector is implied */ |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1856 s->mv_dir = MV_DIR_FORWARD; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1857 s->mv[0][0][0] = s->mv[0][0][1] = 0; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1858 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1859 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1860 s->field_select[0][0]= s->picture_structure - 1; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1861 } else { |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1862 /* if B type, reuse previous vectors and directions */ |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1863 s->mv[0][0][0] = s->last_mv[0][0][0]; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1864 s->mv[0][0][1] = s->last_mv[0][0][1]; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1865 s->mv[1][0][0] = s->last_mv[1][0][0]; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1866 s->mv[1][0][1] = s->last_mv[1][0][1]; |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1867 } |
e0624692025f
move some code which was executed for every skipped MB so it is only executed
michael
parents:
5431
diff
changeset
|
1868 } |
716 | 1869 } |
0 | 1870 } |
1285 | 1871 eos: // end of slice |
1872 *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
|
1873 //printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y); |
1285 | 1874 return 0; |
1875 } | |
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
|
1876 |
1827 | 1877 static int slice_decode_thread(AVCodecContext *c, void *arg){ |
1878 MpegEncContext *s= arg; | |
1861 | 1879 const uint8_t *buf= s->gb.buffer; |
1827 | 1880 int mb_y= s->start_mb_y; |
1881 | |
1882 s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width; | |
1883 | |
1884 for(;;){ | |
3776 | 1885 uint32_t start_code; |
1886 int ret; | |
1827 | 1887 |
1888 ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf); | |
1889 emms_c(); | |
2967 | 1890 //av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n", |
1827 | 1891 //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); |
1892 if(ret < 0){ | |
1893 if(s->resync_mb_x>=0 && s->resync_mb_y>=0) | |
1894 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); | |
1895 }else{ | |
1896 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); | |
1897 } | |
2967 | 1898 |
1827 | 1899 if(s->mb_y == s->end_mb_y) |
1900 return 0; | |
2967 | 1901 |
3086 | 1902 start_code= -1; |
1903 buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code); | |
1827 | 1904 mb_y= start_code - SLICE_MIN_START_CODE; |
1905 if(mb_y < 0 || mb_y >= s->end_mb_y) | |
1906 return -1; | |
1907 } | |
2967 | 1908 |
1827 | 1909 return 0; //not reached |
1910 } | |
1911 | |
1285 | 1912 /** |
1913 * handles slice ends. | |
2967 | 1914 * @return 1 if it seems to be the last slice of |
1285 | 1915 */ |
1916 static int slice_end(AVCodecContext *avctx, AVFrame *pict) | |
1917 { | |
1918 Mpeg1Context *s1 = avctx->priv_data; | |
1919 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
2967 | 1920 |
1402
f662e9c86cf2
* fixing a regression in mpeg encoder (not setting pix_fmt),
romansh
parents:
1389
diff
changeset
|
1921 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
|
1922 return 0; |
fc858abf6b10
fixed segfault if sequence header has not been found before slice decoding
bellard
parents:
1289
diff
changeset
|
1923 |
1381 | 1924 #ifdef HAVE_XVMC |
1925 if(s->avctx->xvmc_acceleration) | |
1926 XVMC_field_end(s); | |
1927 #endif | |
0 | 1928 /* end of slice reached */ |
1285 | 1929 if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) { |
0 | 1930 /* end of image */ |
903 | 1931 |
1728 | 1932 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2; |
1196 | 1933 |
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
|
1934 ff_er_frame_end(s); |
0 | 1935 |
1936 MPV_frame_end(s); | |
1937 | |
924 | 1938 if (s->pict_type == B_TYPE || s->low_delay) { |
1328 | 1939 *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
|
1940 ff_print_debug_info(s, pict); |
0 | 1941 } else { |
903 | 1942 s->picture_number++; |
0 | 1943 /* latency of 1 frame for I and P frames */ |
1944 /* XXX: use another variable than picture_number */ | |
1211 | 1945 if (s->last_picture_ptr != NULL) { |
1328 | 1946 *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
|
1947 ff_print_debug_info(s, pict); |
0 | 1948 } |
1949 } | |
1380 | 1950 |
1285 | 1951 return 1; |
0 | 1952 } else { |
1285 | 1953 return 0; |
0 | 1954 } |
1955 } | |
1956 | |
2967 | 1957 static int mpeg1_decode_sequence(AVCodecContext *avctx, |
1862 | 1958 const uint8_t *buf, int buf_size) |
0 | 1959 { |
1960 Mpeg1Context *s1 = avctx->priv_data; | |
1961 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
|
1962 int width,height; |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1963 int i, v, j; |
401
e20655449d4a
mpeg1/2 identifier - fixed frame rate for some bad mpeg1 streams
glantau
parents:
391
diff
changeset
|
1964 |
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
|
1965 init_get_bits(&s->gb, buf, buf_size*8); |
0 | 1966 |
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
|
1967 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
|
1968 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
|
1969 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
|
1970 (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
|
1971 return -1; |
917 | 1972 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
|
1973 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
|
1974 return -1; |
0 | 1975 s->frame_rate_index = get_bits(&s->gb, 4); |
1837 | 1976 if (s->frame_rate_index == 0 || s->frame_rate_index > 13) |
0 | 1977 return -1; |
1978 s->bit_rate = get_bits(&s->gb, 18) * 400; | |
21 | 1979 if (get_bits1(&s->gb) == 0) /* marker */ |
0 | 1980 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
|
1981 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
|
1982 s->height = height; |
0 | 1983 |
1710
4a68b20eeb2c
print vbv buffer size & bitrate when decoding with -debug 1
michael
parents:
1708
diff
changeset
|
1984 s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16; |
21 | 1985 skip_bits(&s->gb, 1); |
0 | 1986 |
1987 /* get matrix */ | |
21 | 1988 if (get_bits1(&s->gb)) { |
0 | 1989 for(i=0;i<64;i++) { |
1990 v = get_bits(&s->gb, 8); | |
1809 | 1991 if(v==0){ |
1992 av_log(s->avctx, AV_LOG_ERROR, "intra matrix damaged\n"); | |
1993 return -1; | |
1994 } | |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
1995 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
|
1996 s->intra_matrix[j] = v; |
5bf15419d47e
changed quant matrix order (should fix mmx mpeg decoding bug)
glantau
parents:
21
diff
changeset
|
1997 s->chroma_intra_matrix[j] = v; |
0 | 1998 } |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
1999 #ifdef DEBUG |
4652 | 2000 dprintf(s->avctx, "intra matrix present\n"); |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2001 for(i=0;i<64;i++) |
4652 | 2002 dprintf(s->avctx, " %d", s->intra_matrix[s->dsp.idct_permutation[i]]); |
2003 dprintf(s->avctx, "\n"); | |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2004 #endif |
0 | 2005 } else { |
2006 for(i=0;i<64;i++) { | |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
2007 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
|
2008 v = ff_mpeg1_default_intra_matrix[i]; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2009 s->intra_matrix[j] = v; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2010 s->chroma_intra_matrix[j] = v; |
0 | 2011 } |
2012 } | |
21 | 2013 if (get_bits1(&s->gb)) { |
0 | 2014 for(i=0;i<64;i++) { |
2015 v = get_bits(&s->gb, 8); | |
1809 | 2016 if(v==0){ |
2017 av_log(s->avctx, AV_LOG_ERROR, "inter matrix damaged\n"); | |
2018 return -1; | |
2019 } | |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
2020 j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
344 | 2021 s->inter_matrix[j] = v; |
2022 s->chroma_inter_matrix[j] = v; | |
0 | 2023 } |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2024 #ifdef DEBUG |
4652 | 2025 dprintf(s->avctx, "non intra matrix present\n"); |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2026 for(i=0;i<64;i++) |
4652 | 2027 dprintf(s->avctx, " %d", s->inter_matrix[s->dsp.idct_permutation[i]]); |
2028 dprintf(s->avctx, "\n"); | |
59
efd3c19f6d62
fixed mpeg2 non intra dequant - fixed MPEG1 and 2 matrix parsing
glantau
parents:
58
diff
changeset
|
2029 #endif |
0 | 2030 } else { |
2031 for(i=0;i<64;i++) { | |
1092 | 2032 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
|
2033 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
|
2034 s->inter_matrix[j] = v; |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
694
diff
changeset
|
2035 s->chroma_inter_matrix[j] = v; |
0 | 2036 } |
2037 } | |
2967 | 2038 |
1809 | 2039 if(show_bits(&s->gb, 23) != 0){ |
2040 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n"); | |
2041 return -1; | |
2042 } | |
0 | 2043 |
2044 /* we set mpeg2 parameters so that it emulates mpeg1 */ | |
2045 s->progressive_sequence = 1; | |
2046 s->progressive_frame = 1; | |
2047 s->picture_structure = PICT_FRAME; | |
2048 s->frame_pred_frame_dct = 1; | |
1850 | 2049 s->chroma_format = 1; |
1421 | 2050 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
|
2051 avctx->sub_id = 1; /* indicates mpeg1 */ |
1888
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
2052 s->out_format = FMT_MPEG1; |
4bbe33eed9f0
move MPV_common_init after parsing stream parameters, matrix rebuild
iive
parents:
1880
diff
changeset
|
2053 s->swap_uv = 0;//AFAIK VCR2 don't have SEQ_HEADER |
1672 | 2054 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1; |
2967 | 2055 |
1710
4a68b20eeb2c
print vbv buffer size & bitrate when decoding with -debug 1
michael
parents:
1708
diff
changeset
|
2056 if(s->avctx->debug & FF_DEBUG_PICT_INFO) |
2967 | 2057 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n", |
1710
4a68b20eeb2c
print vbv buffer size & bitrate when decoding with -debug 1
michael
parents:
1708
diff
changeset
|
2058 s->avctx->rc_buffer_size, s->bit_rate); |
2967 | 2059 |
0 | 2060 return 0; |
2061 } | |
2062 | |
1376 | 2063 static int vcr2_init_sequence(AVCodecContext *avctx) |
2064 { | |
2065 Mpeg1Context *s1 = avctx->priv_data; | |
2066 MpegEncContext *s = &s1->mpeg_enc_ctx; | |
1377 | 2067 int i, v; |
1376 | 2068 |
2069 /* start new mpeg1 context decoding */ | |
2070 s->out_format = FMT_MPEG1; | |
2071 if (s1->mpeg_enc_ctx_allocated) { | |
2072 MPV_common_end(s); | |
2073 } | |
2270 | 2074 s->width = avctx->coded_width; |
2075 s->height = avctx->coded_height; | |
1376 | 2076 avctx->has_b_frames= 0; //true? |
1380 | 2077 s->low_delay= 1; |
1381 | 2078 |
1821 | 2079 if(avctx->xvmc_acceleration){ |
2080 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420); | |
2081 }else{ | |
2082 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420); | |
2083 } | |
2084 | |
1381 | 2085 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
|
2086 if( avctx->idct_algo == FF_IDCT_AUTO ) |
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2087 avctx->idct_algo = FF_IDCT_SIMPLE; |
2967 | 2088 |
1376 | 2089 if (MPV_common_init(s) < 0) |
2090 return -1; | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2091 exchange_uv(s);//common init reset pblocks, so we swap them here |
2967 | 2092 s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB |
1376 | 2093 s1->mpeg_enc_ctx_allocated = 1; |
2094 | |
2095 for(i=0;i<64;i++) { | |
2096 int j= s->dsp.idct_permutation[i]; | |
2097 v = ff_mpeg1_default_intra_matrix[i]; | |
2098 s->intra_matrix[j] = v; | |
2099 s->chroma_intra_matrix[j] = v; | |
2100 | |
2101 v = ff_mpeg1_default_non_intra_matrix[i]; | |
2102 s->inter_matrix[j] = v; | |
2103 s->chroma_inter_matrix[j] = v; | |
2104 } | |
2105 | |
2106 s->progressive_sequence = 1; | |
2107 s->progressive_frame = 1; | |
2108 s->picture_structure = PICT_FRAME; | |
2109 s->frame_pred_frame_dct = 1; | |
1850 | 2110 s->chroma_format = 1; |
1421 | 2111 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO; |
1377 | 2112 avctx->sub_id = 2; /* indicates mpeg2 */ |
1376 | 2113 return 0; |
2114 } | |
2115 | |
2116 | |
2967 | 2117 static void mpeg_decode_user_data(AVCodecContext *avctx, |
1084 | 2118 const uint8_t *buf, int buf_size) |
2119 { | |
2120 const uint8_t *p; | |
2121 int len, flags; | |
2122 p = buf; | |
2123 len = buf_size; | |
2124 | |
2125 /* we parse the DTG active format information */ | |
2126 if (len >= 5 && | |
2127 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') { | |
2128 flags = p[4]; | |
2129 p += 5; | |
2130 len -= 5; | |
2131 if (flags & 0x80) { | |
2132 /* skip event id */ | |
2133 if (len < 2) | |
2134 return; | |
2135 p += 2; | |
2136 len -= 2; | |
2137 } | |
2138 if (flags & 0x40) { | |
2139 if (len < 1) | |
2140 return; | |
2141 avctx->dtg_active_format = p[0] & 0x0f; | |
2142 } | |
2143 } | |
2144 } | |
2145 | |
2967 | 2146 static void mpeg_decode_gop(AVCodecContext *avctx, |
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
|
2147 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
|
2148 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
|
2149 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
|
2150 |
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
|
2151 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
|
2152 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
|
2153 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
|
2154 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
|
2155 |
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
|
2156 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
|
2157 |
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
|
2158 drop_frame_flag = get_bits1(&s->gb); |
2967 | 2159 |
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
|
2160 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
|
2161 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
|
2162 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
|
2163 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
|
2164 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
|
2165 |
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
|
2166 /*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
|
2167 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
|
2168 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
|
2169 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
|
2170 |
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
|
2171 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
|
2172 av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) broken_link=%d\n", |
2979 | 2173 time_code_hours, time_code_minutes, time_code_seconds, |
2174 time_code_pictures, broken_link); | |
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
|
2175 } |
1211 | 2176 /** |
2177 * finds the end of the current frame in the bitstream. | |
2178 * @return the position of the first byte of the next frame, or -1 | |
2179 */ | |
4916
13ef168891b0
add a ff_ prefix to the now exported mpeg1_find_frame_end() function
aurel
parents:
4915
diff
changeset
|
2180 int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size) |
1988 | 2181 { |
1211 | 2182 int i; |
3086 | 2183 uint32_t state= pc->state; |
2967 | 2184 |
1211 | 2185 i=0; |
2186 if(!pc->frame_start_found){ | |
2187 for(i=0; i<buf_size; i++){ | |
3086 | 2188 i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1; |
1211 | 2189 if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){ |
2190 i++; | |
2191 pc->frame_start_found=1; | |
2192 break; | |
2193 } | |
5449 | 2194 if(state == SEQ_END_CODE){ |
2195 pc->state=-1; | |
2196 return i+1; | |
2197 } | |
1211 | 2198 } |
2199 } | |
2967 | 2200 |
1211 | 2201 if(pc->frame_start_found){ |
1988 | 2202 /* EOF considered as end of frame */ |
2203 if (buf_size == 0) | |
2204 return 0; | |
1211 | 2205 for(; i<buf_size; i++){ |
3086 | 2206 i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1; |
1211 | 2207 if((state&0xFFFFFF00) == 0x100){ |
2208 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){ | |
2209 pc->frame_start_found=0; | |
2967 | 2210 pc->state=-1; |
1211 | 2211 return i-3; |
2212 } | |
2213 } | |
2214 } | |
2967 | 2215 } |
1211 | 2216 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
|
2217 return END_NOT_FOUND; |
1211 | 2218 } |
2219 | |
0 | 2220 /* handle buffering and image synchronisation */ |
2967 | 2221 static int mpeg_decode_frame(AVCodecContext *avctx, |
0 | 2222 void *data, int *data_size, |
1064 | 2223 uint8_t *buf, int buf_size) |
0 | 2224 { |
2225 Mpeg1Context *s = avctx->priv_data; | |
1862 | 2226 const uint8_t *buf_end; |
2227 const uint8_t *buf_ptr; | |
3776 | 2228 uint32_t start_code; |
2229 int ret, input_size; | |
925 | 2230 AVFrame *picture = data; |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
2231 MpegEncContext *s2 = &s->mpeg_enc_ctx; |
4652 | 2232 dprintf(avctx, "fill_buffer\n"); |
0 | 2233 |
5449 | 2234 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) { |
2979 | 2235 /* special case for last picture */ |
2236 if (s2->low_delay==0 && s2->next_picture_ptr) { | |
2237 *picture= *(AVFrame*)s2->next_picture_ptr; | |
2238 s2->next_picture_ptr= NULL; | |
2239 | |
2240 *data_size = sizeof(AVFrame); | |
2241 } | |
0 | 2242 return 0; |
2243 } | |
2244 | |
1211 | 2245 if(s2->flags&CODEC_FLAG_TRUNCATED){ |
4916
13ef168891b0
add a ff_ prefix to the now exported mpeg1_find_frame_end() function
aurel
parents:
4915
diff
changeset
|
2246 int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size); |
2967 | 2247 |
4931
0d1cc37d9430
make some parser parameters const to avoid casting const to non-const
aurel
parents:
4916
diff
changeset
|
2248 if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 ) |
1211 | 2249 return buf_size; |
2967 | 2250 } |
2251 | |
0 | 2252 buf_ptr = buf; |
2253 buf_end = buf + buf_size; | |
383
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2254 |
2967 | 2255 #if 0 |
2256 if (s->repeat_field % 2 == 1) { | |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
2257 s->repeat_field++; |
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
2258 //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
|
2259 // s2->picture_number, s->repeat_field); |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2260 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
|
2261 *data_size = sizeof(AVPicture); |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2262 goto the_end; |
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2263 } |
267
e10840e4f773
- Bug fix MPEG-2 decoder to handle "repeat_first_field" (Telecine)
pulento
parents:
241
diff
changeset
|
2264 } |
383
e6b64bc3bc87
- repeat_pict meaning changed, now it signals the extra delay for the
pulento
parents:
377
diff
changeset
|
2265 #endif |
1376 | 2266 |
2267 if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2")) | |
2268 vcr2_init_sequence(avctx); | |
2967 | 2269 |
1827 | 2270 s->slice_count= 0; |
2967 | 2271 |
1211 | 2272 for(;;) { |
0 | 2273 /* find start next code */ |
3086 | 2274 start_code = -1; |
2275 buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code); | |
3776 | 2276 if (start_code > 0x1ff){ |
2792 | 2277 if(s2->pict_type != B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){ |
1827 | 2278 if(avctx->thread_count > 1){ |
2279 int i; | |
2280 | |
2281 avctx->execute(avctx, slice_decode_thread, (void**)&(s2->thread_context[0]), NULL, s->slice_count); | |
2282 for(i=0; i<s->slice_count; i++) | |
2283 s2->error_count += s2->thread_context[i]->error_count; | |
2284 } | |
1484 | 2285 if (slice_end(avctx, picture)) { |
1672 | 2286 if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice |
1484 | 2287 *data_size = sizeof(AVPicture); |
2288 } | |
1285 | 2289 } |
1220 | 2290 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index); |
0 | 2291 } |
2967 | 2292 |
1289
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2293 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
|
2294 |
57172377849a
fix mpeg1/2 decoding if there are no 0 bytes after the bitstream
michaelni
parents:
1285
diff
changeset
|
2295 if(avctx->debug & FF_DEBUG_STARTCODE){ |
1904 | 2296 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
|
2297 } |
1211 | 2298 |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2299 /* prepare data for next start code */ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2300 switch(start_code) { |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2301 case SEQ_START_CODE: |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2302 mpeg1_decode_sequence(avctx, buf_ptr, |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2303 input_size); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2304 break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2305 |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2306 case PICTURE_START_CODE: |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2307 /* we have a complete image : we try to decompress it */ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2308 mpeg1_decode_picture(avctx, |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2309 buf_ptr, input_size); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2310 break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2311 case EXT_START_CODE: |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2312 mpeg_decode_extension(avctx, |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2313 buf_ptr, input_size); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2314 break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2315 case USER_START_CODE: |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2316 mpeg_decode_user_data(avctx, |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2317 buf_ptr, input_size); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2318 break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2319 case GOP_START_CODE: |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2320 s2->first_field=0; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2321 mpeg_decode_gop(avctx, |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2322 buf_ptr, input_size); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2323 break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2324 default: |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2325 if (start_code >= SLICE_MIN_START_CODE && |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2326 start_code <= SLICE_MAX_START_CODE) { |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2327 int mb_y= start_code - SLICE_MIN_START_CODE; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2328 |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2329 if(s2->last_picture_ptr==NULL){ |
5127 | 2330 /* Skip B-frames if we do not have reference frames. */ |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2331 if(s2->pict_type==B_TYPE) break; |
5127 | 2332 /* Skip P-frames if we do not have reference frame no valid header. */ |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2333 // if(s2->pict_type==P_TYPE && s2->first_field && !s2->first_slice) break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2334 } |
5127 | 2335 /* Skip B-frames if we are in a hurry. */ |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2336 if(avctx->hurry_up && s2->pict_type==B_TYPE) break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2337 if( (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==B_TYPE) |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2338 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=I_TYPE) |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2339 || avctx->skip_frame >= AVDISCARD_ALL) |
0 | 2340 break; |
5127 | 2341 /* Skip everything if we are in a hurry>=5. */ |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2342 if(avctx->hurry_up>=5) break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2343 |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2344 if (!s->mpeg_enc_ctx_allocated) break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2345 |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2346 if(s2->codec_id == CODEC_ID_MPEG2VIDEO){ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2347 if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom) |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2348 break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2349 } |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2350 |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2351 if(s2->first_slice){ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2352 s2->first_slice=0; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2353 if(mpeg_field_start(s2) < 0) |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2354 return -1; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2355 } |
4353
d9cd0e5255d7
fix segfault with http://sam.zoy.org/zzuf/lol-ffplay.mpg and http://sam.zoy.org/zzuf/lol-ffplay.m2v
michael
parents:
4283
diff
changeset
|
2356 if(!s2->current_picture_ptr){ |
5129 | 2357 av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n"); |
4353
d9cd0e5255d7
fix segfault with http://sam.zoy.org/zzuf/lol-ffplay.mpg and http://sam.zoy.org/zzuf/lol-ffplay.m2v
michael
parents:
4283
diff
changeset
|
2358 return -1; |
d9cd0e5255d7
fix segfault with http://sam.zoy.org/zzuf/lol-ffplay.mpg and http://sam.zoy.org/zzuf/lol-ffplay.m2v
michael
parents:
4283
diff
changeset
|
2359 } |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2360 |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2361 if(avctx->thread_count > 1){ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2362 int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2363 if(threshold <= mb_y){ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2364 MpegEncContext *thread_context= s2->thread_context[s->slice_count]; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2365 |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2366 thread_context->start_mb_y= mb_y; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2367 thread_context->end_mb_y = s2->mb_height; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2368 if(s->slice_count){ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2369 s2->thread_context[s->slice_count-1]->end_mb_y= mb_y; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2370 ff_update_duplicate_context(thread_context, s2); |
2786 | 2371 } |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2372 init_get_bits(&thread_context->gb, buf_ptr, input_size*8); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2373 s->slice_count++; |
0 | 2374 } |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2375 buf_ptr += 2; //FIXME add minimum num of bytes per slice |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2376 }else{ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2377 ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2378 emms_c(); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2379 |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2380 if(ret < 0){ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2381 if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0) |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2382 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); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2383 }else{ |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2384 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); |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2385 } |
0 | 2386 } |
4119
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2387 } |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2388 break; |
85438e10d72d
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
4070
diff
changeset
|
2389 } |
0 | 2390 } |
2391 } | |
2392 | |
2393 static int mpeg_decode_end(AVCodecContext *avctx) | |
2394 { | |
2395 Mpeg1Context *s = avctx->priv_data; | |
2396 | |
2397 if (s->mpeg_enc_ctx_allocated) | |
2398 MPV_common_end(&s->mpeg_enc_ctx); | |
2399 return 0; | |
2400 } | |
2401 | |
1423 | 2402 AVCodec mpeg1video_decoder = { |
2403 "mpeg1video", | |
0 | 2404 CODEC_TYPE_VIDEO, |
2405 CODEC_ID_MPEG1VIDEO, | |
2406 sizeof(Mpeg1Context), | |
2407 mpeg_decode_init, | |
2408 NULL, | |
2409 mpeg_decode_end, | |
2410 mpeg_decode_frame, | |
2453 | 2411 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1368 | 2412 .flush= ff_mpeg_flush, |
0 | 2413 }; |
1381 | 2414 |
1423 | 2415 AVCodec mpeg2video_decoder = { |
2416 "mpeg2video", | |
2417 CODEC_TYPE_VIDEO, | |
2418 CODEC_ID_MPEG2VIDEO, | |
2419 sizeof(Mpeg1Context), | |
2420 mpeg_decode_init, | |
2421 NULL, | |
2422 mpeg_decode_end, | |
2423 mpeg_decode_frame, | |
2453 | 2424 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1423 | 2425 .flush= ff_mpeg_flush, |
2426 }; | |
2427 | |
1615 | 2428 //legacy decoder |
2429 AVCodec mpegvideo_decoder = { | |
2430 "mpegvideo", | |
2431 CODEC_TYPE_VIDEO, | |
2432 CODEC_ID_MPEG2VIDEO, | |
2433 sizeof(Mpeg1Context), | |
2434 mpeg_decode_init, | |
2435 NULL, | |
2436 mpeg_decode_end, | |
2437 mpeg_decode_frame, | |
2453 | 2438 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY, |
1615 | 2439 .flush= ff_mpeg_flush, |
2440 }; | |
2441 | |
1381 | 2442 #ifdef HAVE_XVMC |
2443 static int mpeg_mc_decode_init(AVCodecContext *avctx){ | |
2444 Mpeg1Context *s; | |
2445 | |
2967 | 2446 if( avctx->thread_count > 1) |
2076 | 2447 return -1; |
1381 | 2448 if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) ) |
2449 return -1; | |
1580
628bf341e099
XvMC speedup by removing one memcpy and doing MB packing
iive
parents:
1550
diff
changeset
|
2450 if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){ |
4652 | 2451 dprintf(avctx, "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
|
2452 } |
1381 | 2453 mpeg_decode_init(avctx); |
2454 s = avctx->priv_data; | |
2455 | |
2456 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
|
2457 avctx->xvmc_acceleration = 2;//2 - the blocks are packed! |
1381 | 2458 |
2459 return 0; | |
2460 } | |
2461 | |
2462 AVCodec mpeg_xvmc_decoder = { | |
2463 "mpegvideo_xvmc", | |
2464 CODEC_TYPE_VIDEO, | |
2465 CODEC_ID_MPEG2VIDEO_XVMC, | |
2466 sizeof(Mpeg1Context), | |
2467 mpeg_mc_decode_init, | |
2468 NULL, | |
2469 mpeg_decode_end, | |
2470 mpeg_decode_frame, | |
2453 | 2471 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
|
2472 .flush= ff_mpeg_flush, |
1381 | 2473 }; |
2474 | |
2475 #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
|
2476 |
2967 | 2477 /* this is ugly i know, but the alternative is too make |
1410
524c904a66b8
PSX MDEC decoder, based upon some code from Sebastian Jedruszkiewicz <elf at frogger dot rules dot pl>
michaelni
parents:
1409
diff
changeset
|
2478 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
|
2479 which is far uglier. */ |
2967 | 2480 #include "mdec.c" |