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