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