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