annotate mpeg12.c @ 4283:d6f83e2f8804 libavcodec

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