Mercurial > libavcodec.hg
annotate h263.c @ 1490:0355f2b3519a libavcodec
rate distortion optimal cbp support (h263/mpeg4 non intra only)
author | michaelni |
---|---|
date | Tue, 30 Sep 2003 22:18:43 +0000 |
parents | 8e7d8112de29 |
children | 3518325146fc |
rev | line source |
---|---|
0 | 1 /* |
2 * H263/MPEG4 backend for ffmpeg encoder and decoder | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
78 | 4 * H263+ support. |
0 | 5 * Copyright (c) 2001 Juan J. Sierralta P. |
6 * | |
429 | 7 * This library is free software; you can redistribute it and/or |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2 of the License, or (at your option) any later version. | |
0 | 11 * |
429 | 12 * This library is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
429 | 17 * You should have received a copy of the GNU Lesser General Public |
18 * License along with this library; if not, write to the Free Software | |
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
20 * |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
21 * ac prediction encoding, b-frame support, error resilience, optimizations, |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
22 * qpel decoding, gmc decoding, interlaced decoding, |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
23 * by Michael Niedermayer <michaelni@gmx.at> |
0 | 24 */ |
1034 | 25 |
26 /** | |
27 * @file h263.c | |
1106 | 28 * h263/mpeg4 codec. |
1034 | 29 */ |
355 | 30 |
31 //#define DEBUG | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
32 #include <limits.h> |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
33 |
0 | 34 #include "common.h" |
35 #include "dsputil.h" | |
36 #include "avcodec.h" | |
37 #include "mpegvideo.h" | |
38 #include "h263data.h" | |
39 #include "mpeg4data.h" | |
40 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
41 //#undef NDEBUG |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
42 //#include <assert.h> |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
43 |
544 | 44 #define INTRA_MCBPC_VLC_BITS 6 |
1482 | 45 #define INTER_MCBPC_VLC_BITS 7 |
544 | 46 #define CBPY_VLC_BITS 6 |
47 #define MV_VLC_BITS 9 | |
48 #define DC_VLC_BITS 9 | |
49 #define SPRITE_TRAJ_VLC_BITS 6 | |
50 #define MB_TYPE_B_VLC_BITS 4 | |
51 #define TEX_VLC_BITS 9 | |
52 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
53 #ifdef CONFIG_ENCODERS |
0 | 54 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
55 int n); |
324 | 56 static void h263_encode_motion(MpegEncContext * s, int val, int fcode); |
78 | 57 static void h263p_encode_umotion(MpegEncContext * s, int val); |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
58 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
59 int n, int dc, uint8_t *scan_table, |
453 | 60 PutBitContext *dc_pb, PutBitContext *ac_pb); |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
61 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
62 |
262 | 63 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 64 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 65 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
66 int n, int coded); | |
453 | 67 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
68 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 69 int n, int coded, int intra, int rvlc); |
1064 | 70 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr); |
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:
1068
diff
changeset
|
71 #ifdef CONFIG_ENCODERS |
1008 | 72 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
73 int dir); |
1424 | 74 static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
75 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); | |
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:
1068
diff
changeset
|
76 #endif //CONFIG_ENCODERS |
290 | 77 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s); |
1064 | 78 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr); |
79 | |
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:
1068
diff
changeset
|
80 #ifdef CONFIG_ENCODERS |
1064 | 81 static uint8_t uni_DCtab_lum_len[512]; |
82 static uint8_t uni_DCtab_chrom_len[512]; | |
83 static uint16_t uni_DCtab_lum_bits[512]; | |
84 static uint16_t uni_DCtab_chrom_bits[512]; | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
85 |
1162 | 86 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL; |
1064 | 87 static uint8_t fcode_tab[MAX_MV*2+1]; |
88 static uint8_t umv_fcode_tab[MAX_MV*2+1]; | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
89 |
945 | 90 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
91 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
92 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
93 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
94 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level)) | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
95 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 96 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
97 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
98 /* mpeg4 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
99 inter |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
100 max level: 24/6 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
101 max run: 53/63 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
102 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
103 intra |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
104 max level: 53/16 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
105 max run: 29/41 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
106 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
107 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
108 |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
109 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
110 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1") |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
111 #else |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
112 #define IS_3IV1 0 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
113 #endif |
293 | 114 |
0 | 115 int h263_get_picture_format(int width, int height) |
116 { | |
117 int format; | |
118 | |
119 if (width == 128 && height == 96) | |
355 | 120 format = 1; |
0 | 121 else if (width == 176 && height == 144) |
355 | 122 format = 2; |
0 | 123 else if (width == 352 && height == 288) |
355 | 124 format = 3; |
0 | 125 else if (width == 704 && height == 576) |
355 | 126 format = 4; |
0 | 127 else if (width == 1408 && height == 1152) |
355 | 128 format = 5; |
0 | 129 else |
130 format = 7; | |
131 return format; | |
132 } | |
133 | |
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:
1068
diff
changeset
|
134 #ifdef CONFIG_ENCODERS |
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:
1068
diff
changeset
|
135 |
887 | 136 static void float_aspect_to_info(MpegEncContext * s, float aspect){ |
137 int i; | |
138 | |
139 aspect*= s->height/(double)s->width; | |
140 //printf("%f\n", aspect); | |
880 | 141 |
887 | 142 if(aspect==0) aspect= 1.0; |
143 | |
880 | 144 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255); |
887 | 145 |
146 //printf("%d %d\n", s->aspected_width, s->aspected_height); | |
147 for(i=1; i<6; i++){ | |
148 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){ | |
149 s->aspect_ratio_info=i; | |
150 return; | |
151 } | |
152 } | |
880 | 153 |
887 | 154 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 155 } |
156 | |
1354 | 157 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
0 | 158 { |
1354 | 159 int format; |
160 | |
161 align_put_bits(&s->pb); | |
162 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
163 put_bits(&s->pb, 17, 1); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
164 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
165 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
166 s->avctx->frame_rate) & 0xff); /* TemporalReference */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
167 if (s->width == 352 && s->height == 288) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
168 format = 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
169 else if (s->width == 176 && s->height == 144) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
170 format = 3; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
171 else if (s->width == 128 && s->height == 96) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
172 format = 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
173 else if (s->width == 320 && s->height == 240) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
174 format = 5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
175 else if (s->width == 160 && s->height == 120) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
176 format = 6; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
177 else if (s->width <= 255 && s->height <= 255) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
178 format = 0; /* use 1 byte width & height */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
179 else |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
180 format = 1; /* use 2 bytes width & height */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
181 put_bits(&s->pb, 3, format); /* PictureSize */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
182 if (format == 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
183 put_bits(&s->pb, 8, s->width); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
184 put_bits(&s->pb, 8, s->height); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
185 } else if (format == 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
186 put_bits(&s->pb, 16, s->width); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
187 put_bits(&s->pb, 16, s->height); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
188 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
189 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */ |
1390
39d07c0263de
patch for flv deblocking by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1389
diff
changeset
|
190 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */ |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
191 put_bits(&s->pb, 5, s->qscale); /* Quantizer */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
192 put_bits(&s->pb, 1, 0); /* ExtraInformation */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
193 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
194 if(s->h263_aic){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
195 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
196 s->c_dc_scale_table= h263_aic_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
197 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
198 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
199 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
200 } |
1354 | 201 } |
202 | |
203 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
204 { | |
205 int format; | |
206 | |
207 align_put_bits(&s->pb); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
208 |
231 | 209 /* Update the pointer to last GOB */ |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
210 s->ptr_lastgob = pbBufPtr(&s->pb); |
231 | 211 s->gob_number = 0; |
212 | |
213 put_bits(&s->pb, 22, 0x20); /* PSC */ | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
214 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
215 s->avctx->frame_rate) & 0xff); |
0 | 216 |
217 put_bits(&s->pb, 1, 1); /* marker */ | |
218 put_bits(&s->pb, 1, 0); /* h263 id */ | |
219 put_bits(&s->pb, 1, 0); /* split screen off */ | |
220 put_bits(&s->pb, 1, 0); /* camera off */ | |
221 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
78 | 222 |
223 format = h263_get_picture_format(s->width, s->height); | |
0 | 224 if (!s->h263_plus) { |
225 /* H.263v1 */ | |
226 put_bits(&s->pb, 3, format); | |
227 put_bits(&s->pb, 1, (s->pict_type == P_TYPE)); | |
228 /* By now UMV IS DISABLED ON H.263v1, since the restrictions | |
229 of H.263v1 UMV implies to check the predicted MV after | |
230 calculation of the current MB to see if we're on the limits */ | |
231 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */ | |
232 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
233 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */ | |
234 put_bits(&s->pb, 1, 0); /* not PB frame */ | |
235 put_bits(&s->pb, 5, s->qscale); | |
236 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
237 } else { | |
238 /* H.263v2 */ | |
239 /* H.263 Plus PTYPE */ | |
240 put_bits(&s->pb, 3, 7); | |
241 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */ | |
78 | 242 if (format == 7) |
243 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
244 else | |
245 put_bits(&s->pb, 3, format); | |
246 | |
0 | 247 put_bits(&s->pb,1,0); /* Custom PCF: off */ |
1089 | 248 s->umvplus = s->unrestricted_mv; |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
249 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 250 put_bits(&s->pb,1,0); /* SAC: off */ |
251 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
252 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
0 | 253 put_bits(&s->pb,1,0); /* Deblocking Filter: off */ |
254 put_bits(&s->pb,1,0); /* Slice Structured: off */ | |
255 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ | |
256 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
257 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */ | |
258 put_bits(&s->pb,1,0); /* Modified Quantization: off */ | |
259 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
260 put_bits(&s->pb,3,0); /* Reserved */ | |
261 | |
262 put_bits(&s->pb, 3, s->pict_type == P_TYPE); | |
263 | |
264 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ | |
265 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */ | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
266 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 267 put_bits(&s->pb,2,0); /* Reserved */ |
268 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
269 | |
270 /* This should be here if PLUSPTYPE */ | |
271 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
272 | |
78 | 273 if (format == 7) { |
274 /* Custom Picture Format (CPFMT) */ | |
887 | 275 float_aspect_to_info(s, s->avctx->aspect_ratio); |
880 | 276 |
277 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 278 put_bits(&s->pb,9,(s->width >> 2) - 1); |
279 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
280 put_bits(&s->pb,9,(s->height >> 2)); | |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
281 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
282 { |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
283 put_bits(&s->pb, 8, s->aspected_width); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
284 put_bits(&s->pb, 8, s->aspected_height); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
285 } |
78 | 286 } |
287 | |
0 | 288 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
289 if (s->umvplus) |
1089 | 290 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
291 put_bits(&s->pb,2,1); /* unlimited */ | |
292 | |
0 | 293 put_bits(&s->pb, 5, s->qscale); |
294 } | |
295 | |
296 put_bits(&s->pb, 1, 0); /* no PEI */ | |
498 | 297 |
298 if(s->h263_aic){ | |
299 s->y_dc_scale_table= | |
300 s->c_dc_scale_table= h263_aic_dc_scale_table; | |
301 }else{ | |
302 s->y_dc_scale_table= | |
303 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
304 } | |
0 | 305 } |
306 | |
766 | 307 /** |
308 * Encodes a group of blocks header. | |
309 */ | |
162 | 310 int h263_encode_gob_header(MpegEncContext * s, int mb_line) |
311 { | |
312 align_put_bits(&s->pb); | |
231 | 313 flush_put_bits(&s->pb); |
314 /* Call the RTP callback to send the last GOB */ | |
315 if (s->rtp_callback) { | |
766 | 316 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 317 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number); |
318 } | |
162 | 319 put_bits(&s->pb, 17, 1); /* GBSC */ |
231 | 320 s->gob_number = mb_line / s->gob_index; |
162 | 321 put_bits(&s->pb, 5, s->gob_number); /* GN */ |
231 | 322 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ |
162 | 323 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
231 | 324 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif); |
766 | 325 return 0; |
162 | 326 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
327 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
328 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6]) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
329 { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
330 int score0=0, score1=0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
331 int i, n; |
903 | 332 int8_t * const qscale_table= s->current_picture.qscale_table; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
333 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
334 for(n=0; n<6; n++){ |
1064 | 335 int16_t *ac_val, *ac_val1; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
336 |
266 | 337 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
338 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
339 if(dir[n]){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
340 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
341 /* top prediction */ |
266 | 342 ac_val-= s->block_wrap[n]*16; |
903 | 343 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
344 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
345 for(i=1; i<8; i++){ |
1092 | 346 const int level= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
347 score0+= ABS(level); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
348 score1+= ABS(level - ac_val[i+8]); |
1092 | 349 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
350 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
351 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
352 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
353 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
354 for(i=1; i<8; i++){ |
1092 | 355 const int level= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
356 score0+= ABS(level); |
903 | 357 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale)); |
1092 | 358 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
359 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
360 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
361 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
362 }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:
1176
diff
changeset
|
363 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
364 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
365 ac_val-= 16; |
903 | 366 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
367 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
368 for(i=1; i<8; i++){ |
1092 | 369 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
370 score0+= ABS(level); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
371 score1+= ABS(level - ac_val[i]); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
372 ac_val1[i ]= level; |
1092 | 373 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
374 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
375 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
376 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
377 for(i=1; i<8; i++){ |
1092 | 378 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
379 score0+= ABS(level); |
903 | 380 score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale)); |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
381 ac_val1[i ]= level; |
1092 | 382 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
383 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
384 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
385 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
386 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
387 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
388 return score0 > score1 ? 1 : 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
389 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
390 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
391 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
392 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
393 */ |
695 | 394 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
395 int i; |
903 | 396 int8_t * const qscale_table= s->current_picture.qscale_table; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
397 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
398 for(i=1; i<s->mb_num; 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:
1176
diff
changeset
|
399 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >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:
1176
diff
changeset
|
400 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
401 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
402 for(i=s->mb_num-2; i>=0; 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:
1176
diff
changeset
|
403 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >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:
1176
diff
changeset
|
404 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
405 } |
695 | 406 } |
407 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
408 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
409 * modify mb_type & qscale so that encoding is acually possible in mpeg4 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
410 */ |
695 | 411 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
412 int i; | |
903 | 413 int8_t * const qscale_table= s->current_picture.qscale_table; |
414 | |
695 | 415 ff_clean_h263_qscales(s); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
416 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
417 for(i=1; i<s->mb_num; 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:
1176
diff
changeset
|
418 int mb_xy= s->mb_index2xy[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:
1176
diff
changeset
|
419 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
420 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
421 s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
422 s->mb_type[mb_xy]|= MB_TYPE_INTER; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
423 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
424 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
425 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
426 if(s->pict_type== B_TYPE){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
427 int odd=0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
428 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
429 for the actual adaptive quantization */ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
430 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
431 for(i=0; i<s->mb_num; 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:
1176
diff
changeset
|
432 int mb_xy= s->mb_index2xy[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:
1176
diff
changeset
|
433 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
434 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
435 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
436 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
437 else odd=0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
438 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
439 for(i=0; i<s->mb_num; 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:
1176
diff
changeset
|
440 int mb_xy= s->mb_index2xy[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:
1176
diff
changeset
|
441 if((qscale_table[mb_xy]&1) != odd) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
442 qscale_table[mb_xy]++; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
443 if(qscale_table[mb_xy] > 31) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
444 qscale_table[mb_xy]= 31; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
445 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
446 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
447 for(i=1; i<s->mb_num; 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:
1176
diff
changeset
|
448 int mb_xy= s->mb_index2xy[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:
1176
diff
changeset
|
449 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
450 s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
451 s->mb_type[mb_xy]|= MB_TYPE_BIDIR; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
452 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
453 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
454 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
455 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
456 |
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:
1068
diff
changeset
|
457 #endif //CONFIG_ENCODERS |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
458 /** |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
459 * |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
460 * @return the 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:
1176
diff
changeset
|
461 */ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
462 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
463 const int mb_index= s->mb_x + s->mb_y*s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
464 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next? |
936 | 465 int xy= s->block_index[0]; |
466 uint16_t time_pp= s->pp_time; | |
467 uint16_t time_pb= s->pb_time; | |
468 int i; | |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1042
diff
changeset
|
469 |
936 | 470 //FIXME avoid divides |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
471 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
472 if(IS_8X8(colocated_mb_type)){ |
936 | 473 s->mv_type = MV_TYPE_8X8; |
474 for(i=0; i<4; i++){ | |
475 xy= s->block_index[i]; | |
476 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx; | |
477 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my; | |
478 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0] | |
479 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp; | |
480 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] | |
481 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp; | |
482 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
483 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | 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:
1176
diff
changeset
|
484 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 485 s->mv_type = MV_TYPE_FIELD; |
486 for(i=0; i<2; i++){ | |
487 if(s->top_field_first){ | |
488 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i; | |
489 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i; | |
490 }else{ | |
491 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i; | |
492 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i; | |
493 } | |
494 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx; | |
495 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my; | |
496 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0] | |
497 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp; | |
498 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] | |
499 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp; | |
500 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
501 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | 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:
1176
diff
changeset
|
502 }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:
1176
diff
changeset
|
503 s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + 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:
1176
diff
changeset
|
504 s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
505 s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][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:
1176
diff
changeset
|
506 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
507 s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][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:
1176
diff
changeset
|
508 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
509 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
510 s->mv_type= MV_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:
1176
diff
changeset
|
511 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:
1176
diff
changeset
|
512 s->mv_type= MV_TYPE_8X8; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
513 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 514 } |
515 } | |
516 | |
1389 | 517 void ff_h263_update_motion_val(MpegEncContext * s){ |
518 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; | |
519 //FIXME a lot of thet is only needed for !low_delay | |
520 const int wrap = s->block_wrap[0]; | |
521 const int xy = s->block_index[0]; | |
522 | |
523 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; | |
524 | |
525 if(s->mv_type != MV_TYPE_8X8){ | |
526 int motion_x, motion_y; | |
527 if (s->mb_intra) { | |
528 motion_x = 0; | |
529 motion_y = 0; | |
530 } else if (s->mv_type == MV_TYPE_16X16) { | |
531 motion_x = s->mv[0][0][0]; | |
532 motion_y = s->mv[0][0][1]; | |
533 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { | |
534 int i; | |
535 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; | |
536 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; | |
537 motion_x = (motion_x>>1) | (motion_x&1); | |
538 for(i=0; i<2; i++){ | |
539 s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0]; | |
540 s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1]; | |
541 s->field_select_table[mb_xy][i]= s->field_select[0][i]; | |
542 } | |
543 } | |
544 | |
545 /* no update if 8X8 because it has been done during parsing */ | |
546 s->motion_val[xy][0] = motion_x; | |
547 s->motion_val[xy][1] = motion_y; | |
548 s->motion_val[xy + 1][0] = motion_x; | |
549 s->motion_val[xy + 1][1] = motion_y; | |
550 s->motion_val[xy + wrap][0] = motion_x; | |
551 s->motion_val[xy + wrap][1] = motion_y; | |
552 s->motion_val[xy + 1 + wrap][0] = motion_x; | |
553 s->motion_val[xy + 1 + wrap][1] = motion_y; | |
554 } | |
555 | |
556 if(s->encoding){ //FIXME encoding MUST be cleaned up | |
557 if (s->mv_type == MV_TYPE_8X8) | |
558 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; | |
559 else | |
560 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | |
561 } | |
562 } | |
563 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
564 #ifdef CONFIG_ENCODERS |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
565 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
566 static inline int get_p_cbp(MpegEncContext * s, |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
567 DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
568 int motion_x, int motion_y){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
569 int cbp, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
570 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
571 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
572 int best_cbpy_score= INT_MAX; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
573 int best_cbpc_score= INT_MAX; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
574 int cbpc, cbpy; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
575 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
576 const int lambda= (s->qscale*s->qscale*64*105 + 64)>>7; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
577 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
578 for(i=0; i<4; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
579 int score= inter_MCBPC_bits[i + offset] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
580 if(i&1) score += s->coded_score[5]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
581 if(i&2) score += s->coded_score[4]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
582 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
583 if(score < best_cbpc_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
584 best_cbpc_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
585 cbpc= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
586 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
587 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
588 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
589 for(i=0; i<16; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
590 int score= cbpy_tab[i ^ 0xF][1] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
591 if(i&1) score += s->coded_score[3]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
592 if(i&2) score += s->coded_score[2]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
593 if(i&4) score += s->coded_score[1]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
594 if(i&8) score += s->coded_score[0]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
595 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
596 if(score < best_cbpy_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
597 best_cbpy_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
598 cbpy= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
599 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
600 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
601 cbp= cbpc + 4*cbpy; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
602 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
603 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
604 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
605 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
606 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
607 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
608 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
609 s->block_last_index[i]= -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
610 memset(s->block[i], 0, sizeof(DCTELEM)*64); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
611 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
612 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
613 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
614 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
615 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
616 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
617 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
618 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
619 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
620 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
621 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
622 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
623 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
624 int motion_x, int motion_y, int mb_type){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
625 int cbp=0, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
626 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
627 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
628 int score=0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
629 const int lambda= (s->qscale*s->qscale*64*105 + 64)>>7; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
630 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
631 for(i=0; i<6; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
632 if(s->coded_score[i] < 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
633 score += s->coded_score[i]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
634 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
635 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
636 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
637 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
638 if(cbp){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
639 int zero_score= -6; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
640 if ((motion_x | motion_y | s->dquant | mb_type) == 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
641 zero_score-= 4; //2*MV + mb_type + cbp bit |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
642 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
643 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
644 zero_score*= lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
645 if(zero_score <= score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
646 cbp=0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
647 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
648 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
649 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
650 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
651 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
652 s->block_last_index[i]= -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
653 memset(s->block[i], 0, sizeof(DCTELEM)*64); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
654 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
655 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
656 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
657 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
658 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
659 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
660 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
661 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
662 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
663 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
664 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
665 void mpeg4_encode_mb(MpegEncContext * s, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
666 DCTELEM block[6][64], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
667 int motion_x, int motion_y) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
668 { |
1057 | 669 int cbpc, cbpy, pred_x, pred_y; |
453 | 670 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
671 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb; | |
672 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb; | |
673 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
674 const int dquant_code[5]= {1,0,9,2,3}; |
162 | 675 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
676 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
677 if (!s->mb_intra) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
678 /* compute cbp */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
679 int i, cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
680 |
324 | 681 if(s->pict_type==B_TYPE){ |
682 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ | |
683 int mb_type= mb_type_table[s->mv_dir]; | |
684 | |
685 if(s->mb_x==0){ | |
686 s->last_mv[0][0][0]= | |
687 s->last_mv[0][0][1]= | |
688 s->last_mv[1][0][0]= | |
689 s->last_mv[1][0][1]= 0; | |
690 } | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
691 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
692 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
693 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
694 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
695 |
324 | 696 /* nothing to do if this MB was skiped in the next P Frame */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
697 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 698 s->skip_count++; |
699 s->mv[0][0][0]= | |
700 s->mv[0][0][1]= | |
701 s->mv[1][0][0]= | |
702 s->mv[1][0][1]= 0; | |
327 | 703 s->mv_dir= MV_DIR_FORWARD; //doesnt matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
704 s->qscale -= s->dquant; |
903 | 705 // s->mb_skiped=1; |
706 | |
324 | 707 return; |
708 } | |
936 | 709 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
710 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
711 |
324 | 712 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
713 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
714 assert(s->dquant==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
715 |
324 | 716 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 717 |
718 if(interleaved_stats){ | |
719 s->misc_bits++; | |
720 s->last_bits++; | |
721 } | |
324 | 722 s->skip_count++; |
723 return; | |
724 } | |
903 | 725 |
324 | 726 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
727 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge | |
728 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :) | |
729 if(cbp) put_bits(&s->pb, 6, cbp); | |
730 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
731 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
732 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
733 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
734 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
735 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
736 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
737 s->qscale -= s->dquant; |
697 | 738 |
739 if(!s->progressive_sequence){ | |
740 if(cbp) | |
741 put_bits(&s->pb, 1, s->interlaced_dct); | |
742 if(mb_type) // not diect mode | |
743 put_bits(&s->pb, 1, 0); // no interlaced ME yet | |
744 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
745 |
453 | 746 if(interleaved_stats){ |
1164 | 747 s->misc_bits+= get_bits_diff(s); |
453 | 748 } |
295 | 749 |
324 | 750 switch(mb_type) |
751 { | |
752 case 0: /* direct */ | |
753 h263_encode_motion(s, motion_x, 1); | |
754 h263_encode_motion(s, motion_y, 1); | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
755 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
756 s->f_count++; |
324 | 757 break; |
758 case 1: /* bidir */ | |
759 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); | |
760 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
761 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); | |
762 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
763 s->last_mv[0][0][0]= s->mv[0][0][0]; | |
764 s->last_mv[0][0][1]= s->mv[0][0][1]; | |
765 s->last_mv[1][0][0]= s->mv[1][0][0]; | |
766 s->last_mv[1][0][1]= s->mv[1][0][1]; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
767 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
768 s->f_count++; |
324 | 769 break; |
770 case 2: /* backward */ | |
771 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); | |
772 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); | |
773 s->last_mv[1][0][0]= motion_x; | |
774 s->last_mv[1][0][1]= motion_y; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
775 s->b_count++; |
324 | 776 break; |
777 case 3: /* forward */ | |
778 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); | |
779 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); | |
780 s->last_mv[0][0][0]= motion_x; | |
781 s->last_mv[0][0][1]= motion_y; | |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
782 s->f_count++; |
324 | 783 break; |
327 | 784 default: |
785 printf("unknown mb type\n"); | |
324 | 786 return; |
787 } | |
453 | 788 |
789 if(interleaved_stats){ | |
1164 | 790 s->mv_bits+= get_bits_diff(s); |
453 | 791 } |
295 | 792 |
324 | 793 /* encode each block */ |
794 for (i = 0; i < 6; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
795 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb); |
324 | 796 } |
453 | 797 |
798 if(interleaved_stats){ | |
1164 | 799 s->p_tex_bits+= get_bits_diff(s); |
453 | 800 } |
324 | 801 }else{ /* s->pict_type==B_TYPE */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
802 cbp= get_p_cbp(s, block, motion_x, motion_y); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
803 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
804 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
331 | 805 /* check if the B frames can skip it too, as we must skip it if we skip here |
806 why didnt they just compress the skip-mb bits instead of reusing them ?! */ | |
807 if(s->max_b_frames>0){ | |
808 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
809 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
810 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
811 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
812 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
813 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
814 if(x+16 > s->width) x= s->width-16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
815 if(y+16 > s->height) y= s->height-16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
816 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
817 offset= x + y*s->linesize; |
903 | 818 p_pic= s->new_picture.data[0] + offset; |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
819 |
331 | 820 s->mb_skiped=1; |
821 for(i=0; i<s->max_b_frames; i++){ | |
339 | 822 uint8_t *b_pic; |
823 int diff; | |
903 | 824 Picture *pic= s->reordered_input_picture[i+1]; |
825 | |
826 if(pic==NULL || pic->pict_type!=B_TYPE) break; | |
827 | |
828 b_pic= pic->data[0] + offset + 16; //FIXME +16 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
829 diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize); |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
830 if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
331 | 831 s->mb_skiped=0; |
832 break; | |
833 } | |
834 } | |
835 }else | |
836 s->mb_skiped=1; | |
837 | |
838 if(s->mb_skiped==1){ | |
839 /* skip macroblock */ | |
840 put_bits(&s->pb, 1, 1); | |
453 | 841 |
842 if(interleaved_stats){ | |
843 s->misc_bits++; | |
844 s->last_bits++; | |
845 } | |
331 | 846 s->skip_count++; |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
847 |
331 | 848 return; |
849 } | |
295 | 850 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
851 |
324 | 852 put_bits(&s->pb, 1, 0); /* mb coded */ |
853 if(s->mv_type==MV_TYPE_16X16){ | |
854 cbpc = cbp & 3; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
855 if(s->dquant) cbpc+= 8; |
324 | 856 put_bits(&s->pb, |
857 inter_MCBPC_bits[cbpc], | |
858 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
859 |
324 | 860 cbpy = cbp >> 2; |
861 cbpy ^= 0xf; | |
453 | 862 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
863 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
864 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 865 |
866 if(!s->progressive_sequence){ | |
867 if(cbp) | |
868 put_bits(pb2, 1, s->interlaced_dct); | |
869 put_bits(pb2, 1, 0); // no interlaced ME yet | |
870 } | |
324 | 871 |
453 | 872 if(interleaved_stats){ |
1164 | 873 s->misc_bits+= get_bits_diff(s); |
453 | 874 } |
324 | 875 |
876 /* motion vectors: 16x16 mode */ | |
877 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
878 | |
879 h263_encode_motion(s, motion_x - pred_x, s->f_code); | |
880 h263_encode_motion(s, motion_y - pred_y, s->f_code); | |
881 }else{ | |
882 cbpc = (cbp & 3)+16; | |
883 put_bits(&s->pb, | |
884 inter_MCBPC_bits[cbpc], | |
885 inter_MCBPC_code[cbpc]); | |
886 cbpy = cbp >> 2; | |
887 cbpy ^= 0xf; | |
453 | 888 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
889 | |
757 | 890 if(!s->progressive_sequence){ |
891 if(cbp) | |
892 put_bits(pb2, 1, s->interlaced_dct); | |
893 } | |
894 | |
453 | 895 if(interleaved_stats){ |
1164 | 896 s->misc_bits+= get_bits_diff(s); |
453 | 897 } |
324 | 898 |
899 for(i=0; i<4; i++){ | |
900 /* motion vectors: 8x8 mode*/ | |
901 h263_pred_motion(s, i, &pred_x, &pred_y); | |
902 | |
903 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code); | |
904 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code); | |
905 } | |
906 } | |
453 | 907 |
908 if(interleaved_stats){ | |
1164 | 909 s->mv_bits+= get_bits_diff(s); |
453 | 910 } |
324 | 911 |
912 /* encode each block */ | |
913 for (i = 0; i < 6; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
914 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb); |
324 | 915 } |
453 | 916 |
917 if(interleaved_stats){ | |
1164 | 918 s->p_tex_bits+= get_bits_diff(s); |
453 | 919 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
920 s->f_count++; |
295 | 921 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
922 } else { |
324 | 923 int cbp; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
924 int dc_diff[6]; //dc values with the dc prediction subtracted |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
925 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
926 int zigzag_last_index[6]; |
1064 | 927 uint8_t *scan_table[6]; |
1057 | 928 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
929 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
930 for(i=0; i<6; i++){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
931 const int level= block[i][0]; |
1064 | 932 uint16_t *dc_ptr; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
933 |
498 | 934 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
935 if (i < 4) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
936 *dc_ptr = level * s->y_dc_scale; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
937 } else { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
938 *dc_ptr = level * s->c_dc_scale; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
939 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
940 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
941 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
942 s->ac_pred= decide_ac_pred(s, block, dir); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
943 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
944 if(s->ac_pred){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
945 for(i=0; i<6; i++){ |
1064 | 946 uint8_t *st; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
947 int last_index; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
948 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
949 mpeg4_inv_pred_ac(s, block[i], i, dir[i]); |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
950 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */ |
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
951 else st = s->intra_h_scantable.permutated; /* top */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
952 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
953 for(last_index=63; last_index>=0; last_index--) //FIXME optimize |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
954 if(block[i][st[last_index]]) break; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
955 zigzag_last_index[i]= s->block_last_index[i]; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
956 s->block_last_index[i]= last_index; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
957 scan_table[i]= st; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
958 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
959 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
960 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
961 scan_table[i]= s->intra_scantable.permutated; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
962 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
963 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
964 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
965 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
966 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
967 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
968 cbp |= 1 << (5 - i); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
969 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
970 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
971 cbpc = cbp & 3; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
972 if (s->pict_type == I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
973 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
974 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
975 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
976 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
977 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
978 if(s->dquant) cbpc+=8; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
979 put_bits(&s->pb, 1, 0); /* mb coded */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
980 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
981 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
982 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
983 } |
453 | 984 put_bits(pb2, 1, s->ac_pred); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
985 cbpy = cbp >> 2; |
453 | 986 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
987 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
988 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 989 |
697 | 990 if(!s->progressive_sequence){ |
991 put_bits(dc_pb, 1, s->interlaced_dct); | |
992 } | |
993 | |
453 | 994 if(interleaved_stats){ |
1164 | 995 s->misc_bits+= get_bits_diff(s); |
453 | 996 } |
286 | 997 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
998 /* encode each block */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
999 for (i = 0; i < 6; i++) { |
453 | 1000 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1001 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1002 |
453 | 1003 if(interleaved_stats){ |
1164 | 1004 s->i_tex_bits+= get_bits_diff(s); |
453 | 1005 } |
286 | 1006 s->i_count++; |
1007 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1008 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1009 if(s->ac_pred){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1010 for(i=0; i<6; i++){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1011 int j; |
1064 | 1012 int16_t *ac_val; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1013 |
266 | 1014 ac_val = s->ac_val[0][0] + s->block_index[i] * 16; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1015 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1016 if(dir[i]){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1017 for(j=1; j<8; j++) |
1092 | 1018 block[i][s->dsp.idct_permutation[j ]]= ac_val[j+8]; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1019 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1020 for(j=1; j<8; j++) |
1092 | 1021 block[i][s->dsp.idct_permutation[j<<3]]= ac_val[j ]; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1022 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1023 s->block_last_index[i]= zigzag_last_index[i]; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1024 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1025 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1026 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1027 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1028 |
0 | 1029 void h263_encode_mb(MpegEncContext * s, |
1030 DCTELEM block[6][64], | |
1031 int motion_x, int motion_y) | |
1032 { | |
1033 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 1034 int16_t pred_dc; |
1035 int16_t rec_intradc[6]; | |
1036 uint16_t *dc_ptr[6]; | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1037 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
695 | 1038 const int dquant_code[5]= {1,0,9,2,3}; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1039 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1040 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
324 | 1041 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1042 /* compute cbp */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1043 cbp= get_p_cbp(s, block, motion_x, motion_y); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1044 |
695 | 1045 if ((cbp | motion_x | motion_y | s->dquant) == 0) { |
324 | 1046 /* skip macroblock */ |
1047 put_bits(&s->pb, 1, 1); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1048 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1049 s->misc_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1050 s->last_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1051 } |
324 | 1052 return; |
1053 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1054 put_bits(&s->pb, 1, 0); /* mb coded */ |
324 | 1055 cbpc = cbp & 3; |
695 | 1056 if(s->dquant) cbpc+= 8; |
324 | 1057 put_bits(&s->pb, |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1058 inter_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1059 inter_MCBPC_code[cbpc]); |
324 | 1060 cbpy = cbp >> 2; |
1061 cbpy ^= 0xf; | |
1062 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
695 | 1063 if(s->dquant) |
1064 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
0 | 1065 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1066 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1067 s->misc_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1068 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1069 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1070 /* motion vectors: 16x16 mode only now */ |
324 | 1071 h263_pred_motion(s, 0, &pred_x, &pred_y); |
78 | 1072 |
324 | 1073 if (!s->umvplus) { |
1074 h263_encode_motion(s, motion_x - pred_x, s->f_code); | |
1075 h263_encode_motion(s, motion_y - pred_y, s->f_code); | |
1076 } | |
1077 else { | |
1078 h263p_encode_umotion(s, motion_x - pred_x); | |
1079 h263p_encode_umotion(s, motion_y - pred_y); | |
1080 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1081 /* To prevent Start Code emulation */ |
324 | 1082 put_bits(&s->pb,1,1); |
1083 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1084 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1085 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1086 s->mv_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1087 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1088 } else { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1089 int li = s->h263_aic ? 0 : 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1090 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1091 cbp = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1092 for(i=0; i<6; i++) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1093 /* Predict DC */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1094 if (s->h263_aic && s->mb_intra) { |
1064 | 1095 int16_t level = block[i][0]; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1096 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1097 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1098 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1099 /* Quant */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1100 if (level < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1101 level = (level + (s->qscale >> 1))/(s->y_dc_scale); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1102 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1103 level = (level - (s->qscale >> 1))/(s->y_dc_scale); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1104 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1105 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1106 if (level == 0 && s->block_last_index[i] == 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1107 s->block_last_index[i] = -1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1108 else if (level < -127) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1109 level = -127; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1110 else if (level > 127) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1111 level = 127; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1112 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1113 block[i][0] = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1114 /* Reconstruction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1115 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1116 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1117 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1118 //if ((rec_intradc[i] % 2) == 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1119 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1120 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1121 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1122 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1123 else if (rec_intradc[i] > 2047) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1124 rec_intradc[i] = 2047; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1125 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1126 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1127 *dc_ptr[i] = rec_intradc[i]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1128 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1129 /* compute cbp */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1130 if (s->block_last_index[i] >= li) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1131 cbp |= 1 << (5 - i); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1132 } |
0 | 1133 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1134 cbpc = cbp & 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1135 if (s->pict_type == I_TYPE) { |
695 | 1136 if(s->dquant) cbpc+=4; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1137 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1138 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1139 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1140 } else { |
695 | 1141 if(s->dquant) cbpc+=8; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1142 put_bits(&s->pb, 1, 0); /* mb coded */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1143 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1144 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1145 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1146 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1147 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1148 /* XXX: currently, we do not try to use ac prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1149 put_bits(&s->pb, 1, 0); /* no AC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1150 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1151 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1152 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 1153 if(s->dquant) |
1154 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1155 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1156 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1157 s->misc_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1158 } |
0 | 1159 } |
1160 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1161 for(i=0; i<6; i++) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1162 /* encode each block */ |
1354 | 1163 h263_encode_block(s, block[i], i); |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1164 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1165 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1166 if (s->h263_aic && s->mb_intra) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1167 block[i][0] = rec_intradc[i]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1168 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1169 } |
0 | 1170 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1171 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1172 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1173 if (!s->mb_intra) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1174 s->p_tex_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1175 s->f_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1176 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1177 s->i_tex_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1178 s->i_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1179 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1180 } |
0 | 1181 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1182 #endif |
0 | 1183 |
1064 | 1184 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1185 { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1186 int x, y, wrap, a, c, pred_dc, scale; |
1064 | 1187 int16_t *dc_val, *ac_val; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1188 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1189 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1190 if (n < 4) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1191 x = 2 * s->mb_x + 1 + (n & 1); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1192 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1193 wrap = s->mb_width * 2 + 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1194 dc_val = s->dc_val[0]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1195 ac_val = s->ac_val[0][0]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1196 scale = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1197 } else { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1198 x = s->mb_x + 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1199 y = s->mb_y + 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1200 wrap = s->mb_width + 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1201 dc_val = s->dc_val[n - 4 + 1]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1202 ac_val = s->ac_val[n - 4 + 1][0]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1203 scale = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1204 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1205 /* B C |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1206 * A X |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1207 */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1208 a = dc_val[(x - 1) + (y) * wrap]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1209 c = dc_val[(x) + (y - 1) * wrap]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1210 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1211 /* No prediction outside GOB boundary */ |
453 | 1212 if (s->first_slice_line && ((n < 2) || (n > 3))) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1213 c = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1214 pred_dc = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1215 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1216 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1217 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1218 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1219 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1220 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1221 pred_dc = c; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1222 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1223 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1224 //pred_dc = (pred_dc + (scale >> 1)) / scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1225 *dc_val_ptr = &dc_val[x + y * wrap]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1226 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1227 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1228 |
1057 | 1229 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n) |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1230 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1231 int x, y, wrap, a, c, pred_dc, scale, i; |
1064 | 1232 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1233 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1234 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1235 if (n < 4) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1236 x = 2 * s->mb_x + 1 + (n & 1); |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1237 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1238 wrap = s->mb_width * 2 + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1239 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1240 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1241 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1242 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1243 x = s->mb_x + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1244 y = s->mb_y + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1245 wrap = s->mb_width + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1246 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1247 ac_val = s->ac_val[n - 4 + 1][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1248 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1249 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1250 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1251 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1252 ac_val1 = ac_val; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1253 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1254 /* B C |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1255 * A X |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1256 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1257 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1258 c = dc_val[(x) + (y - 1) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1259 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1260 /* No prediction outside GOB boundary */ |
453 | 1261 if (s->first_slice_line && ((n < 2) || (n > 3))) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1262 c = 1024; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1263 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1264 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1265 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1266 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1267 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1268 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1269 for(i=1;i<8;i++) { |
1092 | 1270 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1271 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1272 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1273 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1274 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1275 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1276 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1277 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1278 for(i=1;i<8;i++) { |
1092 | 1279 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1280 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1281 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1282 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1283 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1284 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1285 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1286 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1287 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1288 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1289 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1290 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1291 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1292 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1293 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1294 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1295 block[0]=block[0]*scale + pred_dc; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1296 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1297 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1298 block[0] = 0; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1299 else if (!(block[0] & 1)) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1300 block[0]++; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1301 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1302 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1303 dc_val[(x) + (y) * wrap] = block[0]; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1304 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1305 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1306 for(i=1;i<8;i++) |
1092 | 1307 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1308 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1309 for(i=1;i<8;i++) |
1092 | 1310 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1311 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1312 |
1064 | 1313 int16_t *h263_pred_motion(MpegEncContext * s, int block, |
0 | 1314 int *px, int *py) |
1315 { | |
266 | 1316 int xy, wrap; |
1064 | 1317 int16_t *A, *B, *C, *mot_val; |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1318 static const int off[4]= {2, 1, 1, -1}; |
0 | 1319 |
266 | 1320 wrap = s->block_wrap[0]; |
1321 xy = s->block_index[block]; | |
0 | 1322 |
245 | 1323 mot_val = s->motion_val[xy]; |
0 | 1324 |
453 | 1325 A = s->motion_val[xy - 1]; |
1326 /* special case for first (slice) line */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1327 if (s->first_slice_line && block<3) { |
453 | 1328 // we cant just change some MVs to simulate that as we need them for the B frames (and ME) |
1329 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( | |
1330 if(block==0){ //most common case | |
1331 if(s->mb_x == s->resync_mb_x){ //rare | |
1332 *px= *py = 0; | |
1333 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare | |
1334 C = s->motion_val[xy + off[block] - wrap]; | |
1335 if(s->mb_x==0){ | |
1336 *px = C[0]; | |
1337 *py = C[1]; | |
1338 }else{ | |
1339 *px = mid_pred(A[0], 0, C[0]); | |
1340 *py = mid_pred(A[1], 0, C[1]); | |
1341 } | |
1342 }else{ | |
1343 *px = A[0]; | |
1344 *py = A[1]; | |
1345 } | |
1346 }else if(block==1){ | |
1347 if(s->mb_x + 1 == s->resync_mb_x){ //rare | |
1348 C = s->motion_val[xy + off[block] - wrap]; | |
1349 *px = mid_pred(A[0], 0, C[0]); | |
1350 *py = mid_pred(A[1], 0, C[1]); | |
1351 }else{ | |
1352 *px = A[0]; | |
1353 *py = A[1]; | |
1354 } | |
1355 }else{ /* block==2*/ | |
1356 B = s->motion_val[xy - wrap]; | |
1357 C = s->motion_val[xy + off[block] - wrap]; | |
1358 if(s->mb_x == s->resync_mb_x) //rare | |
1359 A[0]=A[1]=0; | |
1360 | |
1361 *px = mid_pred(A[0], B[0], C[0]); | |
1362 *py = mid_pred(A[1], B[1], C[1]); | |
1363 } | |
0 | 1364 } else { |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1365 B = s->motion_val[xy - wrap]; |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1366 C = s->motion_val[xy + off[block] - wrap]; |
0 | 1367 *px = mid_pred(A[0], B[0], C[0]); |
1368 *py = mid_pred(A[1], B[1], C[1]); | |
1369 } | |
1370 return mot_val; | |
1371 } | |
1372 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1373 #ifdef CONFIG_ENCODERS |
324 | 1374 static void h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1375 { |
702 | 1376 int range, l, bit_size, sign, code, bits; |
0 | 1377 |
1378 if (val == 0) { | |
1379 /* zero vector */ | |
1380 code = 0; | |
1381 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1382 } else { | |
324 | 1383 bit_size = f_code - 1; |
0 | 1384 range = 1 << bit_size; |
1385 /* modulo encoding */ | |
1386 l = range * 32; | |
702 | 1387 #if 1 |
1388 val+= l; | |
1389 val&= 2*l-1; | |
1390 val-= l; | |
1391 sign = val>>31; | |
1392 val= (val^sign)-sign; | |
1393 sign&=1; | |
1394 #else | |
0 | 1395 if (val < -l) { |
702 | 1396 val += 2*l; |
0 | 1397 } else if (val >= l) { |
702 | 1398 val -= 2*l; |
0 | 1399 } |
702 | 1400 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1401 assert(val>=-l && val<l); |
0 | 1402 |
1403 if (val >= 0) { | |
1404 sign = 0; | |
1405 } else { | |
1406 val = -val; | |
1407 sign = 1; | |
1408 } | |
702 | 1409 #endif |
312 | 1410 val--; |
1411 code = (val >> bit_size) + 1; | |
1412 bits = val & (range - 1); | |
0 | 1413 |
1414 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); | |
1415 if (bit_size > 0) { | |
1416 put_bits(&s->pb, bit_size, bits); | |
1417 } | |
1418 } | |
718 | 1419 |
0 | 1420 } |
1421 | |
78 | 1422 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1423 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1424 { | |
1425 short sval = 0; | |
1426 short i = 0; | |
1427 short n_bits = 0; | |
1428 short temp_val; | |
1429 int code = 0; | |
1430 int tcode; | |
1431 | |
1432 if ( val == 0) | |
1433 put_bits(&s->pb, 1, 1); | |
1434 else if (val == 1) | |
1435 put_bits(&s->pb, 3, 0); | |
1436 else if (val == -1) | |
1437 put_bits(&s->pb, 3, 2); | |
1438 else { | |
1439 | |
1440 sval = ((val < 0) ? (short)(-val):(short)val); | |
1441 temp_val = sval; | |
1442 | |
1443 while (temp_val != 0) { | |
1444 temp_val = temp_val >> 1; | |
1445 n_bits++; | |
1446 } | |
1447 | |
1448 i = n_bits - 1; | |
1449 while (i > 0) { | |
1450 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1451 tcode = (tcode << 1) | 1; | |
1452 code = (code << 2) | tcode; | |
1453 i--; | |
1454 } | |
1455 code = ((code << 1) | (val < 0)) << 1; | |
1456 put_bits(&s->pb, (2*n_bits)+1, code); | |
1457 //printf("\nVal = %d\tCode = %d", sval, code); | |
1458 } | |
1459 } | |
1460 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1461 static void init_mv_penalty_and_fcode(MpegEncContext *s) |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1462 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1463 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1464 int mv; |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1465 |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1466 if(mv_penalty==NULL) |
1162 | 1467 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1468 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1469 for(f_code=1; f_code<=MAX_FCODE; f_code++){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1470 for(mv=-MAX_MV; mv<=MAX_MV; mv++){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1471 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1472 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1473 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1474 else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1475 int val, bit_size, range, code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1476 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1477 bit_size = s->f_code - 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1478 range = 1 << bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1479 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1480 val=mv; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1481 if (val < 0) |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1482 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1483 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1484 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1485 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1486 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1487 }else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1488 len= mvtab[32][1] + 2 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1489 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1490 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1491 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1492 mv_penalty[f_code][mv+MAX_MV]= len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1493 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1494 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1495 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1496 for(f_code=MAX_FCODE; f_code>0; f_code--){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1497 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1498 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1499 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1500 } |
287 | 1501 |
1502 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1503 umv_fcode_tab[mv]= 1; | |
1504 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1505 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1506 #endif |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1507 |
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:
1068
diff
changeset
|
1508 #ifdef CONFIG_ENCODERS |
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:
1068
diff
changeset
|
1509 |
468 | 1510 static void init_uni_dc_tab(void) |
293 | 1511 { |
1512 int level, uni_code, uni_len; | |
1513 | |
312 | 1514 for(level=-256; level<256; level++){ |
293 | 1515 int size, v, l; |
1516 /* find number of bits */ | |
1517 size = 0; | |
1518 v = abs(level); | |
1519 while (v) { | |
1520 v >>= 1; | |
1521 size++; | |
1522 } | |
1523 | |
1524 if (level < 0) | |
1525 l= (-level) ^ ((1 << size) - 1); | |
1526 else | |
1527 l= level; | |
1528 | |
1529 /* luminance */ | |
1530 uni_code= DCtab_lum[size][0]; | |
1531 uni_len = DCtab_lum[size][1]; | |
1532 | |
1533 if (size > 0) { | |
1534 uni_code<<=size; uni_code|=l; | |
1535 uni_len+=size; | |
1536 if (size > 8){ | |
1537 uni_code<<=1; uni_code|=1; | |
1538 uni_len++; | |
1539 } | |
1540 } | |
1013 | 1541 uni_DCtab_lum_bits[level+256]= uni_code; |
1542 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1543 |
1544 /* chrominance */ | |
1545 uni_code= DCtab_chrom[size][0]; | |
1546 uni_len = DCtab_chrom[size][1]; | |
1547 | |
1548 if (size > 0) { | |
1549 uni_code<<=size; uni_code|=l; | |
1550 uni_len+=size; | |
1551 if (size > 8){ | |
1552 uni_code<<=1; uni_code|=1; | |
1553 uni_len++; | |
1554 } | |
1555 } | |
1013 | 1556 uni_DCtab_chrom_bits[level+256]= uni_code; |
1557 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1558 |
1559 } | |
1560 } | |
1561 | |
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:
1068
diff
changeset
|
1562 #endif //CONFIG_ENCODERS |
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:
1068
diff
changeset
|
1563 |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1564 #ifdef CONFIG_ENCODERS |
1064 | 1565 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1566 int slevel, run, last; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1567 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1568 assert(MAX_LEVEL >= 64); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1569 assert(MAX_RUN >= 63); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1570 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1571 for(slevel=-64; slevel<64; slevel++){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1572 if(slevel==0) continue; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1573 for(run=0; run<64; run++){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1574 for(last=0; last<=1; last++){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1575 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1576 int level= slevel < 0 ? -slevel : slevel; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1577 int sign= slevel < 0 ? 1 : 0; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1578 int bits, len, code; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1579 int level1, run1; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1580 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1581 len_tab[index]= 100; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1582 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1583 /* ESC0 */ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1584 code= get_rl_index(rl, last, run, level); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1585 bits= rl->table_vlc[code][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1586 len= rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1587 bits=bits*2+sign; len++; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1588 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1589 if(code!=rl->n && len < len_tab[index]){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1590 bits_tab[index]= bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1591 len_tab [index]= len; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1592 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1593 #if 1 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1594 /* ESC1 */ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1595 bits= rl->table_vlc[rl->n][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1596 len= rl->table_vlc[rl->n][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1597 bits=bits*2; len++; //esc1 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1598 level1= level - rl->max_level[last][run]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1599 if(level1>0){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1600 code= get_rl_index(rl, last, run, level1); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1601 bits<<= rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1602 len += rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1603 bits += rl->table_vlc[code][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1604 bits=bits*2+sign; len++; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1605 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1606 if(code!=rl->n && len < len_tab[index]){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1607 bits_tab[index]= bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1608 len_tab [index]= len; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1609 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1610 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1611 #endif |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1612 #if 1 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1613 /* ESC2 */ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1614 bits= rl->table_vlc[rl->n][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1615 len= rl->table_vlc[rl->n][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1616 bits=bits*4+2; len+=2; //esc2 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1617 run1 = run - rl->max_run[last][level] - 1; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1618 if(run1>=0){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1619 code= get_rl_index(rl, last, run1, level); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1620 bits<<= rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1621 len += rl->table_vlc[code][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1622 bits += rl->table_vlc[code][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1623 bits=bits*2+sign; len++; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1624 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1625 if(code!=rl->n && len < len_tab[index]){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1626 bits_tab[index]= bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1627 len_tab [index]= len; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1628 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1629 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1630 #endif |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1631 /* ESC3 */ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1632 bits= rl->table_vlc[rl->n][0]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1633 len = rl->table_vlc[rl->n][1]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1634 bits=bits*4+3; len+=2; //esc3 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1635 bits=bits*2+last; len++; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1636 bits=bits*64+run; len+=6; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1637 bits=bits*2+1; len++; //marker |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1638 bits=bits*4096+(slevel&0xfff); len+=12; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1639 bits=bits*2+1; len++; //marker |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1640 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1641 if(len < len_tab[index]){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1642 bits_tab[index]= bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1643 len_tab [index]= len; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1644 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1645 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1646 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1647 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1648 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1649 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1650 void h263_encode_init(MpegEncContext *s) |
0 | 1651 { |
1652 static int done = 0; | |
1653 | |
1654 if (!done) { | |
1655 done = 1; | |
293 | 1656 |
1657 init_uni_dc_tab(); | |
1658 | |
0 | 1659 init_rl(&rl_inter); |
1660 init_rl(&rl_intra); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1661 init_rl(&rl_intra_aic); |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1662 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1663 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1664 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len); |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1665 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1666 init_mv_penalty_and_fcode(s); |
0 | 1667 } |
936 | 1668 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1669 |
287 | 1670 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 1671 switch(s->codec_id){ |
1672 case CODEC_ID_MPEG4: | |
1673 s->fcode_tab= fcode_tab; | |
1674 s->min_qcoeff= -2048; | |
1675 s->max_qcoeff= 2047; | |
945 | 1676 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
1677 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
1678 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
1679 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 1680 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
1681 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 1682 s->ac_esc_length= 7+2+1+6+1+12+1; |
1424 | 1683 |
1684 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ | |
1483 | 1685 |
1424 | 1686 s->avctx->extradata= av_malloc(1024); |
1687 init_put_bits(&s->pb, s->avctx->extradata, 1024, NULL, NULL); | |
1688 | |
1689 mpeg4_encode_visual_object_header(s); | |
1690 mpeg4_encode_vol_header(s, 0, 0); | |
1691 | |
1692 // ff_mpeg4_stuffing(&s->pb); ? | |
1693 flush_put_bits(&s->pb); | |
1694 s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3; | |
1695 } | |
1696 | |
344 | 1697 break; |
1698 case CODEC_ID_H263P: | |
1699 s->fcode_tab= umv_fcode_tab; | |
1089 | 1700 s->min_qcoeff= -127; |
344 | 1701 s->max_qcoeff= 127; |
1702 break; | |
498 | 1703 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1704 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1705 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1706 s->min_qcoeff= -1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1707 s->max_qcoeff= 1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1708 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1709 s->min_qcoeff= -127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1710 s->max_qcoeff= 127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1711 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1712 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1713 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1714 break; |
344 | 1715 default: //nothing needed default table allready set in mpegvideo.c |
1089 | 1716 s->min_qcoeff= -127; |
344 | 1717 s->max_qcoeff= 127; |
498 | 1718 s->y_dc_scale_table= |
1719 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 1720 } |
0 | 1721 } |
1722 | |
1034 | 1723 /** |
1724 * encodes a 8x8 block. | |
1725 * @param block the 8x8 block | |
1726 * @param n block index (0-3 are luma, 4-5 are chroma) | |
1727 */ | |
0 | 1728 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
1729 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1730 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1731 RLTable *rl; |
0 | 1732 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1733 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1734 if (s->mb_intra && !s->h263_aic) { |
231 | 1735 /* DC coef */ |
1089 | 1736 level = block[0]; |
0 | 1737 /* 255 cannot be represented, so we clamp */ |
1738 if (level > 254) { | |
1739 level = 254; | |
1740 block[0] = 254; | |
1741 } | |
231 | 1742 /* 0 cannot be represented also */ |
1089 | 1743 else if (level < 1) { |
231 | 1744 level = 1; |
1745 block[0] = 1; | |
1746 } | |
1090 | 1747 if (level == 128) //FIXME check rv10 |
1089 | 1748 put_bits(&s->pb, 8, 0xff); |
1749 else | |
1750 put_bits(&s->pb, 8, level & 0xff); | |
1751 i = 1; | |
0 | 1752 } else { |
1089 | 1753 i = 0; |
1754 if (s->h263_aic && s->mb_intra) | |
1755 rl = &rl_intra_aic; | |
0 | 1756 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1757 |
0 | 1758 /* AC coefs */ |
1759 last_index = s->block_last_index[n]; | |
1760 last_non_zero = i - 1; | |
1761 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1762 j = s->intra_scantable.permutated[i]; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1763 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1764 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1765 run = i - last_non_zero - 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1766 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1767 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1768 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1769 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1770 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1771 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1772 } |
0 | 1773 code = get_rl_index(rl, last, run, level); |
1774 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
1775 if (code == rl->n) { | |
1354 | 1776 if(s->h263_flv <= 1){ |
0 | 1777 put_bits(&s->pb, 1, last); |
1778 put_bits(&s->pb, 6, run); | |
1089 | 1779 |
1780 assert(slevel != 0); | |
1781 | |
1782 if(slevel < 128 && slevel > -128) | |
1783 put_bits(&s->pb, 8, slevel & 0xff); | |
1784 else{ | |
1785 put_bits(&s->pb, 8, 128); | |
1786 put_bits(&s->pb, 5, slevel & 0x1f); | |
1787 put_bits(&s->pb, 6, (slevel>>5)&0x3f); | |
1788 } | |
1354 | 1789 }else{ |
1790 if(slevel < 64 && slevel > -64) { | |
1791 /* 7-bit level */ | |
1792 put_bits(&s->pb, 1, 0); | |
1793 put_bits(&s->pb, 1, last); | |
1794 put_bits(&s->pb, 6, run); | |
1795 | |
1796 put_bits(&s->pb, 7, slevel & 0x7f); | |
1797 } else { | |
1798 /* 11-bit level */ | |
1799 put_bits(&s->pb, 1, 1); | |
1800 put_bits(&s->pb, 1, last); | |
1801 put_bits(&s->pb, 6, run); | |
1802 | |
1803 put_bits(&s->pb, 11, slevel & 0x7ff); | |
1804 } | |
1805 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1806 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1807 put_bits(&s->pb, 1, sign); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1808 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1809 last_non_zero = i; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1810 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1811 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1812 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1813 #endif |
0 | 1814 |
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:
1068
diff
changeset
|
1815 #ifdef CONFIG_ENCODERS |
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:
1068
diff
changeset
|
1816 |
0 | 1817 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1818 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1819 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1820 */ |
453 | 1821 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 1822 { |
1823 int length; | |
1824 put_bits(pbc, 1, 0); | |
1825 length= (-get_bit_count(pbc))&7; | |
453 | 1826 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 1827 } |
1828 | |
327 | 1829 /* must be called before writing the header */ |
1830 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ | |
1831 int time_div, time_mod; | |
1832 | |
903 | 1833 if(s->current_picture.pts) |
1834 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000); | |
654 | 1835 else |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
1836 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate); |
327 | 1837 time_div= s->time/s->time_increment_resolution; |
1838 time_mod= s->time%s->time_increment_resolution; | |
1839 | |
1840 if(s->pict_type==B_TYPE){ | |
664 | 1841 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
327 | 1842 }else{ |
1843 s->last_time_base= s->time_base; | |
1844 s->time_base= time_div; | |
1845 s->pp_time= s->time - s->last_non_b_time; | |
1846 s->last_non_b_time= s->time; | |
1847 } | |
1848 } | |
1849 | |
942 | 1850 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
1851 int hours, minutes, seconds; | |
1852 | |
1853 put_bits(&s->pb, 16, 0); | |
1854 put_bits(&s->pb, 16, GOP_STARTCODE); | |
1855 | |
1856 seconds= s->time/s->time_increment_resolution; | |
1857 minutes= seconds/60; seconds %= 60; | |
1858 hours= minutes/60; minutes %= 60; | |
1859 hours%=24; | |
1860 | |
1861 put_bits(&s->pb, 5, hours); | |
1862 put_bits(&s->pb, 6, minutes); | |
1863 put_bits(&s->pb, 1, 1); | |
1864 put_bits(&s->pb, 6, seconds); | |
1865 | |
1866 put_bits(&s->pb, 1, 0); //closed gov == NO | |
1867 put_bits(&s->pb, 1, 0); //broken link == NO | |
1868 | |
1869 ff_mpeg4_stuffing(&s->pb); | |
1870 } | |
1871 | |
1872 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
1873 int profile_and_level_indication; | |
1874 int vo_ver_id; | |
1875 | |
1876 if(s->max_b_frames || s->quarter_sample){ | |
1877 profile_and_level_indication= 0xF1; // adv simple level 1 | |
1878 vo_ver_id= 5; | |
1879 }else{ | |
1880 profile_and_level_indication= 0x01; // simple level 1 | |
1881 vo_ver_id= 1; | |
1882 } | |
1883 //FIXME levels | |
1884 | |
1885 put_bits(&s->pb, 16, 0); | |
1886 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1887 |
942 | 1888 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1889 |
942 | 1890 put_bits(&s->pb, 16, 0); |
1891 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
1892 | |
1893 put_bits(&s->pb, 1, 1); | |
1894 put_bits(&s->pb, 4, vo_ver_id); | |
1895 put_bits(&s->pb, 3, 1); //priority | |
1896 | |
1897 put_bits(&s->pb, 4, 1); //visual obj type== video obj | |
1898 | |
1899 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME | |
1900 | |
1901 ff_mpeg4_stuffing(&s->pb); | |
1902 } | |
1903 | |
1904 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 1905 { |
942 | 1906 int vo_ver_id; |
336 | 1907 |
942 | 1908 if(s->max_b_frames || s->quarter_sample){ |
1909 vo_ver_id= 5; | |
923 | 1910 s->vo_type= ADV_SIMPLE_VO_TYPE; |
1911 }else{ | |
942 | 1912 vo_ver_id= 1; |
923 | 1913 s->vo_type= SIMPLE_VO_TYPE; |
1914 } | |
336 | 1915 |
263 | 1916 put_bits(&s->pb, 16, 0); |
942 | 1917 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 1918 put_bits(&s->pb, 16, 0); |
942 | 1919 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 1920 |
1921 put_bits(&s->pb, 1, 0); /* random access vol */ | |
336 | 1922 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ |
263 | 1923 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
1924 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
1925 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | |
880 | 1926 |
887 | 1927 float_aspect_to_info(s, s->avctx->aspect_ratio); |
880 | 1928 |
1929 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1930 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1931 { |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1932 put_bits(&s->pb, 8, s->aspected_width); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1933 put_bits(&s->pb, 8, s->aspected_height); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1934 } |
336 | 1935 |
1936 if(s->low_delay){ | |
1937 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ | |
341 | 1938 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ |
336 | 1939 put_bits(&s->pb, 1, s->low_delay); |
1940 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ | |
1941 }else{ | |
1942 put_bits(&s->pb, 1, 0); /* vol control parameters= no */ | |
1943 } | |
1944 | |
263 | 1945 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ |
1946 put_bits(&s->pb, 1, 1); /* marker bit */ | |
324 | 1947 |
1948 put_bits(&s->pb, 16, s->time_increment_resolution); | |
263 | 1949 if (s->time_increment_bits < 1) |
1950 s->time_increment_bits = 1; | |
1951 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1952 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
1953 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1954 put_bits(&s->pb, 13, s->width); /* vol width */ | |
1955 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1956 put_bits(&s->pb, 13, s->height); /* vol height */ | |
1957 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 1958 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
263 | 1959 put_bits(&s->pb, 1, 1); /* obmc disable */ |
1960 if (vo_ver_id == 1) { | |
1961 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */ | |
942 | 1962 }else{ |
263 | 1963 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */ |
1964 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1965 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1966 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1967 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ |
599 | 1968 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ |
1411 | 1969 |
1970 if(s->mpeg_quant){ | |
1971 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
1972 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
1973 } | |
599 | 1974 |
263 | 1975 if (vo_ver_id != 1) |
936 | 1976 put_bits(&s->pb, 1, s->quarter_sample); |
263 | 1977 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 1978 s->resync_marker= s->rtp_mode; |
1979 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
1980 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
1981 if(s->data_partitioning){ | |
1982 put_bits(&s->pb, 1, 0); /* no rvlc */ | |
1983 } | |
1984 | |
263 | 1985 if (vo_ver_id != 1){ |
1986 put_bits(&s->pb, 1, 0); /* newpred */ | |
1987 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
1988 } | |
1989 put_bits(&s->pb, 1, 0); /* scalability */ | |
676 | 1990 |
453 | 1991 ff_mpeg4_stuffing(&s->pb); |
676 | 1992 |
1993 /* user data */ | |
1092 | 1994 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 1995 put_bits(&s->pb, 16, 0); |
1996 put_bits(&s->pb, 16, 0x1B2); /* user_data */ | |
1118 | 1997 put_string(&s->pb, LIBAVCODEC_IDENT); |
676 | 1998 ff_mpeg4_stuffing(&s->pb); |
1999 } | |
263 | 2000 } |
2001 | |
2002 /* write mpeg4 VOP header */ | |
2003 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
2004 { | |
324 | 2005 int time_incr; |
2006 int time_div, time_mod; | |
2007 | |
453 | 2008 if(s->pict_type==I_TYPE){ |
953 | 2009 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2010 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2011 mpeg4_encode_visual_object_header(s); |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2012 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2013 mpeg4_encode_vol_header(s, 0, 0); |
942 | 2014 } |
2015 mpeg4_encode_gop_header(s); | |
453 | 2016 } |
324 | 2017 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2018 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2019 |
324 | 2020 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE); |
2021 | |
234
5fc0c3af3fe4
alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents:
231
diff
changeset
|
2022 put_bits(&s->pb, 16, 0); /* vop header */ |
942 | 2023 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ |
0 | 2024 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
324 | 2025 |
327 | 2026 time_div= s->time/s->time_increment_resolution; |
2027 time_mod= s->time%s->time_increment_resolution; | |
324 | 2028 time_incr= time_div - s->last_time_base; |
2029 while(time_incr--) | |
2030 put_bits(&s->pb, 1, 1); | |
2031 | |
0 | 2032 put_bits(&s->pb, 1, 0); |
2033 | |
2034 put_bits(&s->pb, 1, 1); /* marker */ | |
324 | 2035 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ |
0 | 2036 put_bits(&s->pb, 1, 1); /* marker */ |
2037 put_bits(&s->pb, 1, 1); /* vop coded */ | |
263 | 2038 if ( s->pict_type == P_TYPE |
2039 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
0 | 2040 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
2041 } | |
2042 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 2043 if(!s->progressive_sequence){ |
2044 put_bits(&s->pb, 1, s->top_field_first); | |
2045 put_bits(&s->pb, 1, s->alternate_scan); | |
2046 } | |
263 | 2047 //FIXME sprite stuff |
0 | 2048 |
2049 put_bits(&s->pb, 5, s->qscale); | |
2050 | |
2051 if (s->pict_type != I_TYPE) | |
2052 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ | |
263 | 2053 if (s->pict_type == B_TYPE) |
2054 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ | |
0 | 2055 // printf("****frame %d\n", picture_number); |
498 | 2056 |
2057 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support | |
2058 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
0 | 2059 } |
2060 | |
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:
1068
diff
changeset
|
2061 #endif //CONFIG_ENCODERS |
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:
1068
diff
changeset
|
2062 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2063 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2064 * change qscale by given dquant and update qscale dependant variables. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2065 */ |
698 | 2066 static void change_qscale(MpegEncContext * s, int dquant) |
0 | 2067 { |
698 | 2068 s->qscale += dquant; |
2069 | |
2070 if (s->qscale < 1) | |
2071 s->qscale = 1; | |
2072 else if (s->qscale > 31) | |
2073 s->qscale = 31; | |
2074 | |
498 | 2075 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
2076 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | |
0 | 2077 } |
2078 | |
1034 | 2079 /** |
2080 * predicts the dc. | |
2081 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2082 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here | |
2083 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
2084 * @return the quantized predicted dc | |
2085 */ | |
1064 | 2086 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr) |
0 | 2087 { |
266 | 2088 int a, b, c, wrap, pred, scale; |
1064 | 2089 uint16_t *dc_val; |
0 | 2090 |
2091 /* find prediction */ | |
2092 if (n < 4) { | |
2093 scale = s->y_dc_scale; | |
2094 } else { | |
2095 scale = s->c_dc_scale; | |
2096 } | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
2097 if(IS_3IV1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
2098 scale= 8; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
2099 |
266 | 2100 wrap= s->block_wrap[n]; |
2101 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 2102 |
2103 /* B C | |
2104 * A X | |
2105 */ | |
266 | 2106 a = dc_val[ - 1]; |
2107 b = dc_val[ - 1 - wrap]; | |
2108 c = dc_val[ - wrap]; | |
0 | 2109 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2110 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2111 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2112 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2113 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2114 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2115 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2116 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2117 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2118 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2119 |
0 | 2120 if (abs(a - b) < abs(b - c)) { |
2121 pred = c; | |
2122 *dir_ptr = 1; /* top */ | |
2123 } else { | |
2124 pred = a; | |
2125 *dir_ptr = 0; /* left */ | |
2126 } | |
2127 /* we assume pred is positive */ | |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
2128 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 2129 |
2130 /* prepare address for prediction update */ | |
266 | 2131 *dc_val_ptr = &dc_val[0]; |
0 | 2132 |
2133 return pred; | |
2134 } | |
2135 | |
1034 | 2136 /** |
2137 * predicts the ac. | |
2138 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2139 * @param dir the ac prediction direction | |
2140 */ | |
1008 | 2141 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 2142 int dir) |
2143 { | |
266 | 2144 int i; |
1064 | 2145 int16_t *ac_val, *ac_val1; |
903 | 2146 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2147 |
2148 /* find prediction */ | |
266 | 2149 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 2150 ac_val1 = ac_val; |
2151 if (s->ac_pred) { | |
2152 if (dir == 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:
1176
diff
changeset
|
2153 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 2154 /* left prediction */ |
2155 ac_val -= 16; | |
575 | 2156 |
903 | 2157 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 2158 /* same qscale */ |
2159 for(i=1;i<8;i++) { | |
1092 | 2160 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 2161 } |
2162 }else{ | |
2163 /* different qscale, we must rescale */ | |
2164 for(i=1;i<8;i++) { | |
1092 | 2165 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 2166 } |
0 | 2167 } |
2168 } 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:
1176
diff
changeset
|
2169 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 2170 /* top prediction */ |
266 | 2171 ac_val -= 16 * s->block_wrap[n]; |
575 | 2172 |
903 | 2173 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 2174 /* same qscale */ |
2175 for(i=1;i<8;i++) { | |
1092 | 2176 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 2177 } |
2178 }else{ | |
2179 /* different qscale, we must rescale */ | |
2180 for(i=1;i<8;i++) { | |
1092 | 2181 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 2182 } |
0 | 2183 } |
2184 } | |
2185 } | |
2186 /* left copy */ | |
2187 for(i=1;i<8;i++) | |
1092 | 2188 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 2189 |
0 | 2190 /* top copy */ |
2191 for(i=1;i<8;i++) | |
1092 | 2192 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 2193 |
0 | 2194 } |
2195 | |
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:
1068
diff
changeset
|
2196 #ifdef CONFIG_ENCODERS |
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:
1068
diff
changeset
|
2197 |
1008 | 2198 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2199 int dir) |
0 | 2200 { |
266 | 2201 int i; |
1064 | 2202 int16_t *ac_val; |
903 | 2203 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2204 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2205 /* find prediction */ |
266 | 2206 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2207 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2208 if (dir == 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:
1176
diff
changeset
|
2209 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2210 /* left prediction */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2211 ac_val -= 16; |
903 | 2212 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2213 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2214 for(i=1;i<8;i++) { |
1092 | 2215 block[s->dsp.idct_permutation[i<<3]] -= ac_val[i]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2216 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2217 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2218 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2219 for(i=1;i<8;i++) { |
1092 | 2220 block[s->dsp.idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2221 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2222 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2223 } 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:
1176
diff
changeset
|
2224 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2225 /* top prediction */ |
266 | 2226 ac_val -= 16 * s->block_wrap[n]; |
903 | 2227 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2228 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2229 for(i=1;i<8;i++) { |
1092 | 2230 block[s->dsp.idct_permutation[i]] -= ac_val[i + 8]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2231 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2232 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2233 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2234 for(i=1;i<8;i++) { |
1092 | 2235 block[s->dsp.idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2236 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2237 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2238 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2239 } |
0 | 2240 |
1034 | 2241 /** |
2242 * encodes the dc value. | |
2243 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2244 */ | |
453 | 2245 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2246 { |
293 | 2247 #if 1 |
453 | 2248 // if(level<-255 || level>255) printf("dc overflow\n"); |
293 | 2249 level+=256; |
2250 if (n < 4) { | |
2251 /* luminance */ | |
1013 | 2252 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); |
293 | 2253 } else { |
2254 /* chrominance */ | |
1013 | 2255 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); |
293 | 2256 } |
2257 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2258 int size, v; |
0 | 2259 /* find number of bits */ |
2260 size = 0; | |
2261 v = abs(level); | |
2262 while (v) { | |
2263 v >>= 1; | |
2264 size++; | |
2265 } | |
2266 | |
2267 if (n < 4) { | |
2268 /* luminance */ | |
2269 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
2270 } else { | |
2271 /* chrominance */ | |
2272 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
2273 } | |
2274 | |
2275 /* encode remaining bits */ | |
2276 if (size > 0) { | |
2277 if (level < 0) | |
2278 level = (-level) ^ ((1 << size) - 1); | |
2279 put_bits(&s->pb, size, level); | |
2280 if (size > 8) | |
2281 put_bits(&s->pb, 1, 1); | |
2282 } | |
293 | 2283 #endif |
0 | 2284 } |
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:
1068
diff
changeset
|
2285 |
1034 | 2286 /** |
2287 * encodes a 8x8 block | |
2288 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2289 */ | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2290 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2291 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2292 { |
751 | 2293 int i, last_non_zero; |
2294 #if 0 //variables for the outcommented version | |
2295 int code, sign, last; | |
2296 #endif | |
0 | 2297 const RLTable *rl; |
1064 | 2298 uint32_t *bits_tab; |
2299 uint8_t *len_tab; | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2300 const int last_index = s->block_last_index[n]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2301 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2302 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
0 | 2303 /* mpeg4 based DC predictor */ |
453 | 2304 mpeg4_encode_dc(dc_pb, intra_dc, n); |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2305 if(last_index<1) return; |
0 | 2306 i = 1; |
2307 rl = &rl_intra; | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2308 bits_tab= uni_mpeg4_intra_rl_bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2309 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2310 } else { |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2311 if(last_index<0) return; |
0 | 2312 i = 0; |
2313 rl = &rl_inter; | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2314 bits_tab= uni_mpeg4_inter_rl_bits; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2315 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2316 } |
2317 | |
2318 /* AC coefs */ | |
2319 last_non_zero = i - 1; | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2320 #if 1 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2321 for (; i < last_index; i++) { |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2322 int level = block[ scan_table[i] ]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2323 if (level) { |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2324 int run = i - last_non_zero - 1; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2325 level+=64; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2326 if((level&(~127)) == 0){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2327 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2328 put_bits(ac_pb, len_tab[index], bits_tab[index]); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2329 }else{ //ESC3 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2330 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2331 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2332 last_non_zero = i; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2333 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2334 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2335 /*if(i<=last_index)*/{ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2336 int level = block[ scan_table[i] ]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2337 int run = i - last_non_zero - 1; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2338 level+=64; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2339 if((level&(~127)) == 0){ |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2340 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2341 put_bits(ac_pb, len_tab[index], bits_tab[index]); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2342 }else{ //ESC3 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2343 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2344 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2345 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2346 #else |
0 | 2347 for (; i <= last_index; i++) { |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2348 const int slevel = block[ scan_table[i] ]; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2349 if (slevel) { |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2350 int level; |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2351 int run = i - last_non_zero - 1; |
0 | 2352 last = (i == last_index); |
2353 sign = 0; | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2354 level = slevel; |
0 | 2355 if (level < 0) { |
2356 sign = 1; | |
2357 level = -level; | |
2358 } | |
2359 code = get_rl_index(rl, last, run, level); | |
453 | 2360 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2361 if (code == rl->n) { |
2362 int level1, run1; | |
2363 level1 = level - rl->max_level[last][run]; | |
2364 if (level1 < 1) | |
2365 goto esc2; | |
2366 code = get_rl_index(rl, last, run, level1); | |
2367 if (code == rl->n) { | |
2368 esc2: | |
453 | 2369 put_bits(ac_pb, 1, 1); |
0 | 2370 if (level > MAX_LEVEL) |
2371 goto esc3; | |
2372 run1 = run - rl->max_run[last][level] - 1; | |
2373 if (run1 < 0) | |
2374 goto esc3; | |
2375 code = get_rl_index(rl, last, run1, level); | |
2376 if (code == rl->n) { | |
2377 esc3: | |
2378 /* third escape */ | |
453 | 2379 put_bits(ac_pb, 1, 1); |
2380 put_bits(ac_pb, 1, last); | |
2381 put_bits(ac_pb, 6, run); | |
2382 put_bits(ac_pb, 1, 1); | |
2383 put_bits(ac_pb, 12, slevel & 0xfff); | |
2384 put_bits(ac_pb, 1, 1); | |
0 | 2385 } else { |
2386 /* second escape */ | |
453 | 2387 put_bits(ac_pb, 1, 0); |
2388 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2389 put_bits(ac_pb, 1, sign); | |
0 | 2390 } |
2391 } else { | |
2392 /* first escape */ | |
453 | 2393 put_bits(ac_pb, 1, 0); |
2394 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2395 put_bits(ac_pb, 1, sign); | |
0 | 2396 } |
2397 } else { | |
453 | 2398 put_bits(ac_pb, 1, sign); |
0 | 2399 } |
2400 last_non_zero = i; | |
2401 } | |
2402 } | |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2403 #endif |
0 | 2404 } |
936 | 2405 |
2406 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, | |
1064 | 2407 uint8_t *scan_table) |
936 | 2408 { |
2409 int i, last_non_zero; | |
2410 const RLTable *rl; | |
1064 | 2411 uint8_t *len_tab; |
936 | 2412 const int last_index = s->block_last_index[n]; |
2413 int len=0; | |
2414 | |
2415 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2416 /* mpeg4 based DC predictor */ | |
2417 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME | |
2418 if(last_index<1) return len; | |
2419 i = 1; | |
2420 rl = &rl_intra; | |
2421 len_tab = uni_mpeg4_intra_rl_len; | |
2422 } else { | |
2423 if(last_index<0) return 0; | |
2424 i = 0; | |
2425 rl = &rl_inter; | |
2426 len_tab = uni_mpeg4_inter_rl_len; | |
2427 } | |
2428 | |
2429 /* AC coefs */ | |
2430 last_non_zero = i - 1; | |
2431 for (; i < last_index; i++) { | |
2432 int level = block[ scan_table[i] ]; | |
2433 if (level) { | |
2434 int run = i - last_non_zero - 1; | |
2435 level+=64; | |
2436 if((level&(~127)) == 0){ | |
2437 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2438 len += len_tab[index]; | |
2439 }else{ //ESC3 | |
2440 len += 7+2+1+6+1+12+1; | |
2441 } | |
2442 last_non_zero = i; | |
2443 } | |
2444 } | |
2445 /*if(i<=last_index)*/{ | |
2446 int level = block[ scan_table[i] ]; | |
2447 int run = i - last_non_zero - 1; | |
2448 level+=64; | |
2449 if((level&(~127)) == 0){ | |
2450 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2451 len += len_tab[index]; | |
2452 }else{ //ESC3 | |
2453 len += 7+2+1+6+1+12+1; | |
2454 } | |
2455 } | |
2456 | |
2457 return len; | |
2458 } | |
2459 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2460 #endif |
0 | 2461 |
2462 | |
2463 /***********************************************/ | |
2464 /* decoding */ | |
2465 | |
2466 static VLC intra_MCBPC_vlc; | |
2467 static VLC inter_MCBPC_vlc; | |
2468 static VLC cbpy_vlc; | |
2469 static VLC mv_vlc; | |
2470 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2471 static VLC sprite_trajectory; |
262 | 2472 static VLC mb_type_b_vlc; |
0 | 2473 |
2474 void init_vlc_rl(RLTable *rl) | |
2475 { | |
542 | 2476 int i, q; |
2477 | |
0 | 2478 init_vlc(&rl->vlc, 9, rl->n + 1, |
2479 &rl->table_vlc[0][1], 4, 2, | |
2480 &rl->table_vlc[0][0], 4, 2); | |
542 | 2481 |
2482 | |
2483 for(q=0; q<32; q++){ | |
2484 int qmul= q*2; | |
2485 int qadd= (q-1)|1; | |
2486 | |
2487 if(q==0){ | |
2488 qmul=1; | |
2489 qadd=0; | |
2490 } | |
2491 | |
2492 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); | |
2493 for(i=0; i<rl->vlc.table_size; i++){ | |
2494 int code= rl->vlc.table[i][0]; | |
2495 int len = rl->vlc.table[i][1]; | |
2496 int level, run; | |
2497 | |
2498 if(len==0){ // illegal code | |
563 | 2499 run= 66; |
542 | 2500 level= MAX_LEVEL; |
2501 }else if(len<0){ //more bits needed | |
2502 run= 0; | |
2503 level= code; | |
2504 }else{ | |
2505 if(code==rl->n){ //esc | |
563 | 2506 run= 66; |
542 | 2507 level= 0; |
2508 }else{ | |
2509 run= rl->table_run [code] + 1; | |
2510 level= rl->table_level[code] * qmul + qadd; | |
2511 if(code >= rl->last) run+=192; | |
2512 } | |
2513 } | |
2514 rl->rl_vlc[q][i].len= len; | |
2515 rl->rl_vlc[q][i].level= level; | |
2516 rl->rl_vlc[q][i].run= run; | |
2517 } | |
2518 } | |
0 | 2519 } |
2520 | |
2521 /* init vlcs */ | |
2522 | |
2523 /* XXX: find a better solution to handle static init */ | |
2524 void h263_decode_init_vlc(MpegEncContext *s) | |
2525 { | |
2526 static int done = 0; | |
2527 | |
2528 if (!done) { | |
2529 done = 1; | |
2530 | |
1482 | 2531 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
0 | 2532 intra_MCBPC_bits, 1, 1, |
2533 intra_MCBPC_code, 1, 1); | |
1482 | 2534 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, |
0 | 2535 inter_MCBPC_bits, 1, 1, |
2536 inter_MCBPC_code, 1, 1); | |
544 | 2537 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16, |
0 | 2538 &cbpy_tab[0][1], 2, 1, |
2539 &cbpy_tab[0][0], 2, 1); | |
544 | 2540 init_vlc(&mv_vlc, MV_VLC_BITS, 33, |
0 | 2541 &mvtab[0][1], 2, 1, |
2542 &mvtab[0][0], 2, 1); | |
2543 init_rl(&rl_inter); | |
2544 init_rl(&rl_intra); | |
1132 | 2545 init_rl(&rvlc_rl_inter); |
2546 init_rl(&rvlc_rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
2547 init_rl(&rl_intra_aic); |
0 | 2548 init_vlc_rl(&rl_inter); |
2549 init_vlc_rl(&rl_intra); | |
1132 | 2550 init_vlc_rl(&rvlc_rl_inter); |
2551 init_vlc_rl(&rvlc_rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
2552 init_vlc_rl(&rl_intra_aic); |
549 | 2553 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2554 &DCtab_lum[0][1], 2, 1, |
2555 &DCtab_lum[0][0], 2, 1); | |
549 | 2556 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, |
0 | 2557 &DCtab_chrom[0][1], 2, 1, |
2558 &DCtab_chrom[0][0], 2, 1); | |
544 | 2559 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15, |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2560 &sprite_trajectory_tab[0][1], 4, 2, |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2561 &sprite_trajectory_tab[0][0], 4, 2); |
544 | 2562 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, |
262 | 2563 &mb_type_b_tab[0][1], 2, 1, |
2564 &mb_type_b_tab[0][0], 2, 1); | |
0 | 2565 } |
2566 } | |
2567 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2568 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2569 * Get the GOB height based on picture height. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2570 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2571 int ff_h263_get_gob_height(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2572 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2573 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2574 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2575 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2576 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2577 return 4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2578 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2579 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2580 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2581 * decodes the group of blocks header. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2582 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2583 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2584 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 2585 { |
2586 unsigned int val, gfid; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2587 int left; |
162 | 2588 |
2589 /* Check for GOB Start Code */ | |
2590 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2591 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2592 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2593 |
162 | 2594 /* We have a GBSC probably with GSTUFF */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2595 skip_bits(&s->gb, 16); /* Drop the zeros */ |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
2596 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2597 //MN: we must check the bits left or we might end in a infinite loop (or segfault) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2598 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2599 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2600 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2601 if(left<=13) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2602 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2603 |
162 | 2604 #ifdef DEBUG |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2605 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x); |
162 | 2606 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2607 s->gob_number = get_bits(&s->gb, 5); /* GN */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2608 gfid = get_bits(&s->gb, 2); /* GFID */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2609 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2610 if(s->qscale==0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2611 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2612 s->mb_x= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2613 s->mb_y= s->gob_index* s->gob_number; |
1393 | 2614 if(s->mb_y >= s->mb_height) |
2615 return -1; | |
162 | 2616 #ifdef DEBUG |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2617 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale); |
162 | 2618 #endif |
2619 return 0; | |
2620 } | |
2621 | |
290 | 2622 static inline void memsetw(short *tab, int val, int n) |
2623 { | |
2624 int i; | |
2625 for(i=0;i<n;i++) | |
2626 tab[i] = val; | |
2627 } | |
2628 | |
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:
1068
diff
changeset
|
2629 #ifdef CONFIG_ENCODERS |
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:
1068
diff
changeset
|
2630 |
453 | 2631 void ff_mpeg4_init_partitions(MpegEncContext *s) |
2632 { | |
2633 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL); | |
2634 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL); | |
2635 } | |
2636 | |
2637 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 2638 { |
453 | 2639 const int pb2_len = get_bit_count(&s->pb2 ); |
2640 const int tex_pb_len= get_bit_count(&s->tex_pb); | |
2641 const int bits= get_bit_count(&s->pb); | |
2642 | |
2643 if(s->pict_type==I_TYPE){ | |
2644 put_bits(&s->pb, 19, DC_MARKER); | |
2645 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
2646 s->i_tex_bits+= tex_pb_len; | |
2647 }else{ | |
2648 put_bits(&s->pb, 17, MOTION_MARKER); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2649 s->misc_bits+=17 + pb2_len; |
453 | 2650 s->mv_bits+= bits - s->last_bits; |
2651 s->p_tex_bits+= tex_pb_len; | |
2652 } | |
2653 | |
2654 flush_put_bits(&s->pb2); | |
2655 flush_put_bits(&s->tex_pb); | |
2656 | |
2657 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len); | |
2658 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len); | |
2659 s->last_bits= get_bit_count(&s->pb); | |
2660 } | |
2661 | |
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:
1068
diff
changeset
|
2662 #endif //CONFIG_ENCODERS |
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:
1068
diff
changeset
|
2663 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2664 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2665 switch(s->pict_type){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2666 case I_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2667 return 16; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2668 case P_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2669 case S_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2670 return s->f_code+15; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2671 case B_TYPE: |
847 | 2672 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2673 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2674 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2675 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2676 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2677 |
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:
1068
diff
changeset
|
2678 #ifdef CONFIG_ENCODERS |
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:
1068
diff
changeset
|
2679 |
453 | 2680 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
2681 { | |
2682 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
2683 | |
2684 ff_mpeg4_stuffing(&s->pb); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2685 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 2686 put_bits(&s->pb, 1, 1); |
2687 | |
2688 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2689 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 2690 put_bits(&s->pb, 1, 0); /* no HEC */ |
2691 } | |
2692 | |
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:
1068
diff
changeset
|
2693 #endif //CONFIG_ENCODERS |
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:
1068
diff
changeset
|
2694 |
453 | 2695 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2696 * check if the next stuff is a resync marker or the end. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2697 * @return 0 if not |
453 | 2698 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2699 static inline int mpeg4_is_resync(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2700 const int bits_count= get_bits_count(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2701 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2702 if(s->workaround_bugs&FF_BUG_NO_PADDING){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2703 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2704 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2705 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
2706 if(bits_count + 8 >= s->gb.size_in_bits){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2707 int v= show_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2708 v|= 0x7F >> (7-(bits_count&7)); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2709 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2710 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2711 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2712 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2713 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2714 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2715 GetBitContext gb= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2716 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2717 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2718 align_get_bits(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2719 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2720 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2721 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2722 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2723 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2724 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2725 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2726 if(len>=ff_mpeg4_get_video_packet_prefix_length(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2727 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2728 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2729 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2730 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2731 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2732 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2733 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2734 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2735 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2736 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2737 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 2738 { |
290 | 2739 int mb_num_bits= av_log2(s->mb_num - 1) + 1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2740 int header_extension=0, mb_num, len; |
453 | 2741 |
2742 /* is there enough space left for a video packet + header */ | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
2743 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2744 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2745 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2746 if(get_bits1(&s->gb)) break; |
453 | 2747 } |
2748 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2749 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2750 printf("marker does not match f_code\n"); |
453 | 2751 return -1; |
2752 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2753 |
453 | 2754 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2755 header_extension= get_bits1(&s->gb); |
453 | 2756 //FIXME more stuff here |
2757 } | |
2758 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2759 mb_num= get_bits(&s->gb, mb_num_bits); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2760 if(mb_num>=s->mb_num){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2761 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 2762 return -1; |
2763 } | |
1176 | 2764 if(s->pict_type == B_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:
1176
diff
changeset
|
2765 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
1176 | 2766 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded |
2767 } | |
2768 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2769 s->mb_x= mb_num % s->mb_width; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2770 s->mb_y= mb_num / s->mb_width; |
453 | 2771 |
2772 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2773 int qscale= get_bits(&s->gb, s->quant_precision); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2774 if(qscale) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2775 s->qscale= qscale; |
290 | 2776 } |
2777 | |
2778 if(s->shape == RECT_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2779 header_extension= get_bits1(&s->gb); |
290 | 2780 } |
2781 if(header_extension){ | |
453 | 2782 int time_increment; |
290 | 2783 int time_incr=0; |
453 | 2784 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2785 while (get_bits1(&s->gb) != 0) |
290 | 2786 time_incr++; |
2787 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2788 check_marker(&s->gb, "before time_increment in video packed header"); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2789 time_increment= get_bits(&s->gb, s->time_increment_bits); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2790 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
290 | 2791 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2792 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 2793 //FIXME not rect stuff here |
2794 | |
2795 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2796 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2797 //FIXME dont just ignore everything |
821 | 2798 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
290 | 2799 mpeg4_decode_sprite_trajectory(s); |
660 | 2800 fprintf(stderr, "untested\n"); |
290 | 2801 } |
2802 | |
2803 //FIXME reduced res stuff here | |
2804 | |
2805 if (s->pict_type != I_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2806 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 2807 if(f_code==0){ |
2808 printf("Error, video packet header damaged (f_code=0)\n"); | |
290 | 2809 } |
2810 } | |
2811 if (s->pict_type == B_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2812 int b_code = get_bits(&s->gb, 3); |
660 | 2813 if(b_code==0){ |
2814 printf("Error, video packet header damaged (b_code=0)\n"); | |
2815 } | |
290 | 2816 } |
2817 } | |
2818 } | |
2819 //FIXME new-pred stuff | |
453 | 2820 |
2821 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb)); | |
2822 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2823 return 0; |
453 | 2824 } |
2825 | |
2826 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
2827 { | |
2828 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 2829 |
2830 l_wrap= s->block_wrap[0]; | |
453 | 2831 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2; |
290 | 2832 c_wrap= s->block_wrap[4]; |
453 | 2833 c_xy= s->mb_y*c_wrap + s->mb_x; |
290 | 2834 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2835 #if 0 |
290 | 2836 /* clean DC */ |
453 | 2837 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
2838 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
2839 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2840 #endif |
290 | 2841 |
2842 /* clean AC */ | |
1064 | 2843 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
2844 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
2845 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 2846 |
2847 /* clean MV */ | |
453 | 2848 // we cant clear the MVs as they might be needed by a b frame |
1064 | 2849 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
2850 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 2851 s->last_mv[0][0][0]= |
2852 s->last_mv[0][0][1]= | |
2853 s->last_mv[1][0][0]= | |
2854 s->last_mv[1][0][1]= 0; | |
2855 } | |
2856 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2857 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2858 * decodes the group of blocks / video packet header. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2859 * @return <0 if no resync found |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2860 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2861 int ff_h263_resync(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2862 int left, ret; |
453 | 2863 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2864 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2865 skip_bits1(&s->gb); |
453 | 2866 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2867 align_get_bits(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2868 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2869 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2870 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2871 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2872 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2873 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2874 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2875 return 0; |
453 | 2876 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2877 //ok, its not where its supposed to be ... |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2878 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2879 align_get_bits(&s->gb); |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
2880 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
453 | 2881 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2882 for(;left>16+1+5+5; left-=8){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2883 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2884 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2885 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2886 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2887 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2888 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2889 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2890 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2891 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2892 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2893 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2894 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2895 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2896 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2897 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2898 return -1; |
453 | 2899 } |
2900 | |
2901 /** | |
1034 | 2902 * gets the average motion vector for a GMC MB. |
753 | 2903 * @param n either 0 for the x component or 1 for y |
2904 * @returns the average MV for a GMC MB | |
2905 */ | |
2906 static inline int get_amv(MpegEncContext *s, int n){ | |
2907 int x, y, mb_v, sum, dx, dy, shift; | |
2908 int len = 1 << (s->f_code + 4); | |
2909 const int a= s->sprite_warping_accuracy; | |
2910 | |
2911 if(s->real_sprite_warping_points==1){ | |
2912 if(s->divx_version==500 && s->divx_build==413) | |
2913 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
2914 else | |
2915 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
2916 }else{ | |
2917 dx= s->sprite_delta[n][0]; | |
2918 dy= s->sprite_delta[n][1]; | |
2919 shift= s->sprite_shift[0]; | |
2920 if(n) dy -= 1<<(shift + a + 1); | |
2921 else dx -= 1<<(shift + a + 1); | |
2922 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
2923 | |
2924 sum=0; | |
2925 for(y=0; y<16; y++){ | |
2926 int v; | |
2927 | |
2928 v= mb_v + dy*y; | |
2929 //XXX FIXME optimize | |
2930 for(x=0; x<16; x++){ | |
2931 sum+= v>>shift; | |
2932 v+= dx; | |
2933 } | |
2934 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
2935 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 2936 } |
2937 | |
2938 if (sum < -len) sum= -len; | |
2939 else if (sum >= len) sum= len-1; | |
2940 | |
2941 return sum; | |
2942 } | |
2943 | |
2944 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2945 * decodes first partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2946 * @return number of MBs decoded or <0 if an error occured |
453 | 2947 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2948 static int mpeg4_decode_partition_a(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2949 int mb_num; |
1064 | 2950 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
453 | 2951 |
2952 /* decode first partition */ | |
2953 mb_num=0; | |
290 | 2954 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2955 for(; s->mb_y<s->mb_height; s->mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2956 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2957 for(; s->mb_x<s->mb_width; s->mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2958 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 2959 int cbpc; |
2960 int dir=0; | |
2961 | |
2962 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2963 ff_update_block_index(s); |
453 | 2964 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
2965 s->first_slice_line=0; | |
2966 | |
2967 if(s->pict_type==I_TYPE){ | |
2968 int i; | |
2969 | |
1257 | 2970 if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2971 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2972 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2973 |
1482 | 2974 do{ |
2975 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
2976 if (cbpc < 0){ | |
2977 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2978 return -1; | |
2979 } | |
2980 }while(cbpc == 8); | |
2981 | |
453 | 2982 s->cbp_table[xy]= cbpc & 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:
1176
diff
changeset
|
2983 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 2984 s->mb_intra = 1; |
2985 | |
2986 if(cbpc & 4) { | |
698 | 2987 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 2988 } |
903 | 2989 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 2990 |
2991 s->mbintra_table[xy]= 1; | |
2992 for(i=0; i<6; i++){ | |
2993 int dc_pred_dir; | |
2994 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
2995 if(dc < 0){ | |
2996 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2997 return -1; |
453 | 2998 } |
2999 dir<<=1; | |
3000 if(dc_pred_dir) dir|=1; | |
3001 } | |
3002 s->pred_dir_table[xy]= dir; | |
3003 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3004 int mx, my, pred_x, pred_y, bits; |
1064 | 3005 int16_t * const mot_val= s->motion_val[s->block_index[0]]; |
453 | 3006 const int stride= s->block_wrap[0]*2; |
3007 | |
1483 | 3008 // do{ //FIXME |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3009 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3010 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3011 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3012 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3013 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3014 if(bits&0x10000){ |
453 | 3015 /* skip mb */ |
3016 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3017 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 3018 mx= get_amv(s, 0); |
3019 my= get_amv(s, 1); | |
453 | 3020 }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:
1176
diff
changeset
|
3021 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3022 mx=my=0; |
453 | 3023 } |
3024 mot_val[0 ]= mot_val[2 ]= | |
3025 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3026 mot_val[1 ]= mot_val[3 ]= | |
3027 mot_val[1+stride]= mot_val[3+stride]= my; | |
3028 | |
3029 if(s->mbintra_table[xy]) | |
3030 ff_clean_intra_table_entries(s); | |
3031 continue; | |
3032 } | |
1482 | 3033 |
544 | 3034 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 3035 if (cbpc < 0){ |
3036 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3037 return -1; |
453 | 3038 } |
1483 | 3039 // }while(cbpc == 20); |
1482 | 3040 |
453 | 3041 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
3042 | |
3043 s->mb_intra = ((cbpc & 4) != 0); | |
3044 | |
3045 if(s->mb_intra){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3046 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3047 s->mbintra_table[xy]= 1; |
3048 mot_val[0 ]= mot_val[2 ]= | |
3049 mot_val[0+stride]= mot_val[2+stride]= 0; | |
3050 mot_val[1 ]= mot_val[3 ]= | |
3051 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3052 }else{ | |
3053 if(s->mbintra_table[xy]) | |
3054 ff_clean_intra_table_entries(s); | |
3055 | |
3056 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | |
3057 s->mcsel= get_bits1(&s->gb); | |
3058 else s->mcsel= 0; | |
3059 | |
3060 if ((cbpc & 16) == 0) { | |
3061 /* 16x16 motion prediction */ | |
3062 | |
3063 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
753 | 3064 if(!s->mcsel){ |
3065 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3066 if (mx >= 0xffff) | |
3067 return -1; | |
3068 | |
3069 my = h263_decode_motion(s, pred_y, s->f_code); | |
3070 if (my >= 0xffff) | |
3071 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:
1176
diff
changeset
|
3072 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3073 } else { |
3074 mx = get_amv(s, 0); | |
3075 my = get_amv(s, 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:
1176
diff
changeset
|
3076 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 3077 } |
753 | 3078 |
453 | 3079 mot_val[0 ]= mot_val[2 ] = |
3080 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3081 mot_val[1 ]= mot_val[3 ]= | |
3082 mot_val[1+stride]= mot_val[3+stride]= my; | |
3083 } else { | |
3084 int 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:
1176
diff
changeset
|
3085 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 3086 for(i=0;i<4;i++) { |
1064 | 3087 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); |
453 | 3088 mx = h263_decode_motion(s, pred_x, s->f_code); |
3089 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3090 return -1; |
453 | 3091 |
3092 my = h263_decode_motion(s, pred_y, s->f_code); | |
3093 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3094 return -1; |
453 | 3095 mot_val[0] = mx; |
3096 mot_val[1] = my; | |
3097 } | |
3098 } | |
3099 } | |
3100 } | |
3101 } | |
3102 s->mb_x= 0; | |
3103 } | |
3104 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3105 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3106 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3107 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3108 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3109 * decode second partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3110 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3111 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3112 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3113 int mb_num=0; |
1064 | 3114 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3115 |
453 | 3116 s->mb_x= s->resync_mb_x; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3117 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3118 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3119 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3120 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3121 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3122 |
3123 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3124 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3125 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3126 s->first_slice_line=0; |
453 | 3127 |
3128 if(s->pict_type==I_TYPE){ | |
3129 int ac_pred= get_bits1(&s->gb); | |
544 | 3130 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3131 if(cbpy<0){ |
3132 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3133 return -1; |
453 | 3134 } |
3135 | |
3136 s->cbp_table[xy]|= cbpy<<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:
1176
diff
changeset
|
3137 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 3138 }else{ /* P || S_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:
1176
diff
changeset
|
3139 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 3140 int dir=0,i; |
3141 int ac_pred = get_bits1(&s->gb); | |
544 | 3142 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3143 |
3144 if(cbpy<0){ | |
3145 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3146 return -1; |
453 | 3147 } |
3148 | |
3149 if(s->cbp_table[xy] & 8) { | |
698 | 3150 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 3151 } |
903 | 3152 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3153 |
3154 for(i=0; i<6; i++){ | |
3155 int dc_pred_dir; | |
3156 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
3157 if(dc < 0){ | |
3158 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3159 return -1; |
453 | 3160 } |
3161 dir<<=1; | |
3162 if(dc_pred_dir) dir|=1; | |
3163 } | |
3164 s->cbp_table[xy]&= 3; //remove dquant | |
3165 s->cbp_table[xy]|= cbpy<<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:
1176
diff
changeset
|
3166 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3167 s->pred_dir_table[xy]= dir; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3168 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 3169 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3170 s->cbp_table[xy]= 0; |
3171 }else{ | |
544 | 3172 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3173 |
3174 if(cbpy<0){ | |
3175 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3176 return -1; |
453 | 3177 } |
3178 | |
3179 if(s->cbp_table[xy] & 8) { | |
698 | 3180 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 3181 } |
903 | 3182 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3183 |
3184 s->cbp_table[xy]&= 3; //remove dquant | |
3185 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3186 } | |
3187 } | |
3188 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3189 if(mb_num >= mb_count) return 0; |
453 | 3190 s->mb_x= 0; |
3191 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3192 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3193 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3194 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3195 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3196 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3197 * @return <0 if error (and sets error type in the error_status_table) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3198 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3199 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3200 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3201 int mb_num; |
1144 | 3202 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
3203 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END; | |
453 | 3204 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3205 mb_num= mpeg4_decode_partition_a(s); |
1144 | 3206 if(mb_num<0){ |
3207 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3208 return -1; |
1144 | 3209 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3210 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3211 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3212 fprintf(stderr, "slice below monitor ...\n"); |
1144 | 3213 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3214 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3215 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3216 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3217 s->mb_num_left= mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3218 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3219 if(s->pict_type==I_TYPE){ |
1257 | 3220 if(get_bits_long(&s->gb, 19)!=DC_MARKER){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3221 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3222 return -1; |
1144 | 3223 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3224 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3225 if(get_bits(&s->gb, 17)!=MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3226 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3227 return -1; |
1144 | 3228 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3229 } |
1144 | 3230 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3231 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3232 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
1144 | 3233 if(s->pict_type==P_TYPE) |
3234 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3235 return -1; |
1144 | 3236 }else{ |
3237 if(s->pict_type==P_TYPE) | |
3238 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3239 } |
453 | 3240 |
3241 return 0; | |
3242 } | |
3243 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3244 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3245 * decode partition C of one MB. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3246 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3247 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3248 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 3249 { |
3250 int 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:
1176
diff
changeset
|
3251 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3252 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3253 mb_type= s->current_picture.mb_type[xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3254 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3255 |
903 | 3256 if(s->current_picture.qscale_table[xy] != s->qscale){ |
3257 s->qscale= s->current_picture.qscale_table[xy]; | |
698 | 3258 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
3259 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | |
453 | 3260 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3261 |
453 | 3262 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
3263 int i; | |
3264 for(i=0; i<4; i++){ | |
3265 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0]; | |
3266 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1]; | |
3267 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3268 s->mb_intra = IS_INTRA(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:
1176
diff
changeset
|
3269 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3270 if (IS_SKIP(mb_type)) { |
453 | 3271 /* skip mb */ |
3272 for(i=0;i<6;i++) | |
3273 s->block_last_index[i] = -1; | |
3274 s->mv_dir = MV_DIR_FORWARD; | |
3275 s->mv_type = MV_TYPE_16X16; | |
3276 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
3277 s->mcsel=1; | |
3278 s->mb_skiped = 0; | |
3279 }else{ | |
3280 s->mcsel=0; | |
3281 s->mb_skiped = 1; | |
3282 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3283 }else if(s->mb_intra){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3284 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3285 }else if(!s->mb_intra){ |
3286 // s->mcsel= 0; //FIXME do we need to init that | |
3287 | |
3288 s->mv_dir = MV_DIR_FORWARD; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3289 if (IS_8X8(mb_type)) { |
453 | 3290 s->mv_type = MV_TYPE_8X8; |
3291 } else { | |
3292 s->mv_type = MV_TYPE_16X16; | |
3293 } | |
3294 } | |
3295 } else { /* I-Frame */ | |
3296 s->mb_intra = 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:
1176
diff
changeset
|
3297 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3298 } |
3299 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3300 if (!IS_SKIP(mb_type)) { |
1132 | 3301 int i; |
453 | 3302 /* decode each block */ |
3303 for (i = 0; i < 6; i++) { | |
1132 | 3304 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ |
3305 fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); | |
453 | 3306 return -1; |
3307 } | |
718 | 3308 cbp+=cbp; |
453 | 3309 } |
3310 } | |
290 | 3311 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3312 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3313 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3314 if(--s->mb_num_left <= 0){ |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
3315 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb)); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3316 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3317 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3318 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3319 return SLICE_NOEND; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3320 }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:
1176
diff
changeset
|
3321 if(mpeg4_is_resync(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:
1176
diff
changeset
|
3322 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 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:
1176
diff
changeset
|
3323 if(s->cbp_table[xy+delta]) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3324 return SLICE_END; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3325 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3326 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3327 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3328 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3329 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3330 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3331 DCTELEM block[6][64]) |
0 | 3332 { |
3333 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3334 int16_t *mot_val; |
3335 static int8_t quant_tab[4] = { -1, -2, 1, 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:
1176
diff
changeset
|
3336 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
359 | 3337 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3338 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
1482 | 3339 do{ |
21 | 3340 if (get_bits1(&s->gb)) { |
0 | 3341 /* skip mb */ |
3342 s->mb_intra = 0; | |
3343 for(i=0;i<6;i++) | |
3344 s->block_last_index[i] = -1; | |
3345 s->mv_dir = MV_DIR_FORWARD; | |
3346 s->mv_type = MV_TYPE_16X16; | |
255 | 3347 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3348 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3349 s->mcsel=1; |
753 | 3350 s->mv[0][0][0]= get_amv(s, 0); |
3351 s->mv[0][0][1]= get_amv(s, 1); | |
255 | 3352 |
3353 s->mb_skiped = 0; | |
3354 }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:
1176
diff
changeset
|
3355 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3356 s->mcsel=0; |
3357 s->mv[0][0][0] = 0; | |
3358 s->mv[0][0][1] = 0; | |
3359 s->mb_skiped = 1; | |
3360 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3361 goto end; |
0 | 3362 } |
544 | 3363 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
144 | 3364 //fprintf(stderr, "\tCBPC: %d", cbpc); |
1482 | 3365 if (cbpc < 0){ |
3366 fprintf(stderr, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
0 | 3367 return -1; |
1482 | 3368 } |
3369 }while(cbpc == 20); | |
144 | 3370 |
0 | 3371 dquant = cbpc & 8; |
3372 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3373 if (s->mb_intra) goto intra; |
3374 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3375 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3376 s->mcsel= get_bits1(&s->gb); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3377 else s->mcsel= 0; |
544 | 3378 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
0 | 3379 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2); |
3380 if (dquant) { | |
698 | 3381 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
0 | 3382 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3383 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE))) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3384 s->interlaced_dct= get_bits1(&s->gb); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3385 |
0 | 3386 s->mv_dir = MV_DIR_FORWARD; |
3387 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3388 if(s->mcsel){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3389 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3390 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3391 s->mv_type = MV_TYPE_16X16; |
753 | 3392 mx= get_amv(s, 0); |
3393 my= get_amv(s, 1); | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3394 s->mv[0][0][0] = mx; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3395 s->mv[0][0][1] = my; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3396 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3397 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3398 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3399 s->mv_type= MV_TYPE_FIELD; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3400 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3401 s->field_select[0][0]= get_bits1(&s->gb); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3402 s->field_select[0][1]= get_bits1(&s->gb); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3403 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3404 h263_pred_motion(s, 0, &pred_x, &pred_y); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3405 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3406 for(i=0; i<2; i++){ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3407 mx = h263_decode_motion(s, pred_x, s->f_code); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3408 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3409 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3410 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3411 my = h263_decode_motion(s, pred_y/2, s->f_code); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3412 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3413 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3414 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3415 s->mv[0][i][0] = mx; |
661 | 3416 s->mv[0][i][1] = my; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3417 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3418 }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:
1176
diff
changeset
|
3419 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3420 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3421 s->mv_type = MV_TYPE_16X16; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3422 h263_pred_motion(s, 0, &pred_x, &pred_y); |
1089 | 3423 if (s->umvplus) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3424 mx = h263p_decode_umotion(s, pred_x); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3425 else |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3426 mx = h263_decode_motion(s, pred_x, s->f_code); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3427 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3428 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3429 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3430 |
1089 | 3431 if (s->umvplus) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3432 my = h263p_decode_umotion(s, pred_y); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3433 else |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3434 my = h263_decode_motion(s, pred_y, s->f_code); |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3435 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3436 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3437 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3438 s->mv[0][0][0] = mx; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3439 s->mv[0][0][1] = my; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3440 |
1089 | 3441 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3442 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
255 | 3443 } |
0 | 3444 } 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:
1176
diff
changeset
|
3445 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 3446 s->mv_type = MV_TYPE_8X8; |
3447 for(i=0;i<4;i++) { | |
3448 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); | |
1089 | 3449 if (s->umvplus) |
78 | 3450 mx = h263p_decode_umotion(s, pred_x); |
3451 else | |
262 | 3452 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 3453 if (mx >= 0xffff) |
3454 return -1; | |
78 | 3455 |
1089 | 3456 if (s->umvplus) |
78 | 3457 my = h263p_decode_umotion(s, pred_y); |
3458 else | |
262 | 3459 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 3460 if (my >= 0xffff) |
3461 return -1; | |
3462 s->mv[0][i][0] = mx; | |
3463 s->mv[0][i][1] = my; | |
1089 | 3464 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
78 | 3465 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
0 | 3466 mot_val[0] = mx; |
3467 mot_val[1] = my; | |
3468 } | |
3469 } | |
262 | 3470 } else if(s->pict_type==B_TYPE) { |
3471 int modb1; // first bit of modb | |
3472 int modb2; // second bit of modb | |
3473 int mb_type; | |
3474 | |
3475 s->mb_intra = 0; //B-frames never contain intra blocks | |
3476 s->mcsel=0; // ... true gmc blocks | |
3477 | |
3478 if(s->mb_x==0){ | |
674 | 3479 for(i=0; i<2; i++){ |
3480 s->last_mv[i][0][0]= | |
3481 s->last_mv[i][0][1]= | |
3482 s->last_mv[i][1][0]= | |
3483 s->last_mv[i][1][1]= 0; | |
3484 } | |
262 | 3485 } |
3486 | |
3487 /* if we skipped it in the future P Frame than skip it now too */ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3488 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC |
262 | 3489 |
3490 if(s->mb_skiped){ | |
3491 /* skip mb */ | |
3492 for(i=0;i<6;i++) | |
3493 s->block_last_index[i] = -1; | |
3494 | |
3495 s->mv_dir = MV_DIR_FORWARD; | |
3496 s->mv_type = MV_TYPE_16X16; | |
3497 s->mv[0][0][0] = 0; | |
3498 s->mv[0][0][1] = 0; | |
3499 s->mv[1][0][0] = 0; | |
3500 s->mv[1][0][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:
1176
diff
changeset
|
3501 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3502 goto end; |
262 | 3503 } |
3504 | |
666 | 3505 modb1= get_bits1(&s->gb); |
3506 if(modb1){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3507 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 3508 cbp=0; |
3509 }else{ | |
262 | 3510 modb2= get_bits1(&s->gb); |
544 | 3511 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 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:
1176
diff
changeset
|
3512 if(mb_type<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:
1176
diff
changeset
|
3513 printf("illegal MB_type\n"); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3514 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:
1176
diff
changeset
|
3515 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3516 mb_type= mb_type_b_map[ mb_type ]; |
666 | 3517 if(modb2) cbp= 0; |
3518 else cbp= get_bits(&s->gb, 6); | |
3519 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3520 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 3521 if(get_bits1(&s->gb)){ |
698 | 3522 change_qscale(s, get_bits1(&s->gb)*4 - 2); |
262 | 3523 } |
3524 } | |
664 | 3525 |
3526 if(!s->progressive_sequence){ | |
3527 if(cbp) | |
3528 s->interlaced_dct= get_bits1(&s->gb); | |
3529 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3530 if(!IS_DIRECT(mb_type) && 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:
1176
diff
changeset
|
3531 mb_type |= MB_TYPE_16x8 | 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:
1176
diff
changeset
|
3532 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:
1176
diff
changeset
|
3533 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3534 if(USES_LIST(mb_type, 0)){ |
667 | 3535 s->field_select[0][0]= get_bits1(&s->gb); |
3536 s->field_select[0][1]= get_bits1(&s->gb); | |
3537 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3538 if(USES_LIST(mb_type, 1)){ |
667 | 3539 s->field_select[1][0]= get_bits1(&s->gb); |
3540 s->field_select[1][1]= get_bits1(&s->gb); | |
3541 } | |
3542 } | |
666 | 3543 } |
3544 | |
667 | 3545 s->mv_dir = 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:
1176
diff
changeset
|
3546 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 3547 s->mv_type= MV_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:
1176
diff
changeset
|
3548 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3549 if(USES_LIST(mb_type, 0)){ |
666 | 3550 s->mv_dir = MV_DIR_FORWARD; |
3551 | |
3552 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
3553 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
3554 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
3555 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 3556 } |
666 | 3557 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3558 if(USES_LIST(mb_type, 1)){ |
666 | 3559 s->mv_dir |= MV_DIR_BACKWARD; |
3560 | |
3561 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
3562 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
3563 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
3564 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
3565 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3566 }else if(!IS_DIRECT(mb_type)){ |
666 | 3567 s->mv_type= MV_TYPE_FIELD; |
667 | 3568 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3569 if(USES_LIST(mb_type, 0)){ |
666 | 3570 s->mv_dir = MV_DIR_FORWARD; |
3571 | |
3572 for(i=0; i<2; i++){ | |
3573 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
3574 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
3575 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
3576 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
3577 } | |
667 | 3578 } |
666 | 3579 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3580 if(USES_LIST(mb_type, 1)){ |
666 | 3581 s->mv_dir |= MV_DIR_BACKWARD; |
3582 | |
3583 for(i=0; i<2; i++){ | |
3584 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
3585 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
3586 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
3587 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 3588 } |
3589 } | |
3590 } | |
3591 } | |
666 | 3592 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3593 if(IS_DIRECT(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:
1176
diff
changeset
|
3594 if(IS_SKIP(mb_type)) |
666 | 3595 mx=my=0; |
3596 else{ | |
3597 mx = h263_decode_motion(s, 0, 1); | |
3598 my = h263_decode_motion(s, 0, 1); | |
3599 } | |
664 | 3600 |
262 | 3601 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3602 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 3603 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3604 s->current_picture.mb_type[xy]= mb_type; |
262 | 3605 } else { /* I-Frame */ |
1482 | 3606 do{ |
3607 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
3608 if (cbpc < 0){ | |
3609 fprintf(stderr, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
3610 return -1; | |
3611 } | |
3612 }while(cbpc == 8); | |
3613 | |
262 | 3614 dquant = cbpc & 4; |
3615 s->mb_intra = 1; | |
3616 intra: | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3617 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3618 if (s->h263_pred || s->h263_aic) { |
21 | 3619 s->ac_pred = get_bits1(&s->gb); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3620 if(s->ac_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:
1176
diff
changeset
|
3621 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3622 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3623 if (s->h263_aic) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3624 s->h263_aic_dir = 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:
1176
diff
changeset
|
3625 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3626 }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:
1176
diff
changeset
|
3627 s->ac_pred = 0; |
591 | 3628 |
544 | 3629 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1482 | 3630 if(cbpy<0){ |
3631 fprintf(stderr, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
3632 return -1; | |
3633 } | |
0 | 3634 cbp = (cbpc & 3) | (cbpy << 2); |
3635 if (dquant) { | |
698 | 3636 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
0 | 3637 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3638 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3639 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3640 s->interlaced_dct= get_bits1(&s->gb); |
575 | 3641 |
3642 /* decode each block */ | |
3643 if (s->h263_pred) { | |
3644 for (i = 0; i < 6; i++) { | |
1132 | 3645 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) |
575 | 3646 return -1; |
718 | 3647 cbp+=cbp; |
575 | 3648 } |
3649 } else { | |
3650 for (i = 0; i < 6; i++) { | |
718 | 3651 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
575 | 3652 return -1; |
718 | 3653 cbp+=cbp; |
575 | 3654 } |
3655 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3656 goto end; |
0 | 3657 } |
3658 | |
3659 /* decode each block */ | |
3660 if (s->h263_pred) { | |
575 | 3661 for (i = 0; i < 6; i++) { |
1132 | 3662 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) |
0 | 3663 return -1; |
718 | 3664 cbp+=cbp; |
575 | 3665 } |
0 | 3666 } else { |
575 | 3667 for (i = 0; i < 6; i++) { |
718 | 3668 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
0 | 3669 return -1; |
718 | 3670 cbp+=cbp; |
575 | 3671 } |
0 | 3672 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3673 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3674 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3675 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3676 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3677 if(mpeg4_is_resync(s)){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3678 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 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:
1176
diff
changeset
|
3679 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta]) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3680 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3681 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3682 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3683 }else{ |
892
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3684 int v= show_bits(&s->gb, 16); |
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3685 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
3686 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
3687 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3688 } |
892
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3689 |
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3690 if(v==0) |
550033bc7e2d
fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents:
887
diff
changeset
|
3691 return SLICE_END; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3692 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3693 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3694 return SLICE_OK; |
0 | 3695 } |
3696 | |
262 | 3697 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 3698 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
3699 int code, val, sign, shift, l; |
544 | 3700 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 3701 |
3702 if (code == 0) | |
3703 return pred; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3704 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:
1176
diff
changeset
|
3705 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3706 |
21 | 3707 sign = get_bits1(&s->gb); |
262 | 3708 shift = f_code - 1; |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3709 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3710 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3711 val = (val - 1) << shift; |
0 | 3712 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
|
3713 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3714 } |
0 | 3715 if (sign) |
3716 val = -val; | |
3717 val += pred; | |
475 | 3718 |
0 | 3719 /* modulo decoding */ |
3720 if (!s->h263_long_vectors) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3721 l = 1 << (f_code + 4); |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3722 val = ((val + l)&(l*2-1)) - l; |
0 | 3723 } else { |
3724 /* horrible h263 long vector mode */ | |
3725 if (pred < -31 && val < -63) | |
3726 val += 64; | |
3727 if (pred > 32 && val > 63) | |
3728 val -= 64; | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
3729 |
0 | 3730 } |
3731 return val; | |
3732 } | |
3733 | |
78 | 3734 /* Decodes RVLC of H.263+ UMV */ |
3735 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
3736 { | |
3737 int code = 0, sign; | |
3738 | |
3739 if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
3740 return pred; | |
3741 | |
3742 code = 2 + get_bits1(&s->gb); | |
3743 | |
3744 while (get_bits1(&s->gb)) | |
3745 { | |
3746 code <<= 1; | |
3747 code += get_bits1(&s->gb); | |
3748 } | |
3749 sign = code & 1; | |
3750 code >>= 1; | |
3751 | |
3752 code = (sign) ? (pred - code) : (pred + code); | |
3753 #ifdef DEBUG | |
3754 fprintf(stderr,"H.263+ UMV Motion = %d\n", code); | |
3755 #endif | |
3756 return code; | |
3757 | |
3758 } | |
3759 | |
0 | 3760 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
3761 int n, int coded) | |
3762 { | |
3763 int code, level, i, j, last, run; | |
3764 RLTable *rl = &rl_inter; | |
1064 | 3765 const uint8_t *scan_table; |
0 | 3766 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3767 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3768 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3769 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3770 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3771 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3772 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3773 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3774 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3775 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3776 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3777 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3778 /* DC coef */ |
1090 | 3779 if(s->h263_rv10){ |
3780 if (s->rv10_version == 3 && s->pict_type == I_TYPE) { | |
0 | 3781 int component, diff; |
3782 component = (n <= 3 ? 0 : n - 4 + 1); | |
3783 level = s->last_dc[component]; | |
3784 if (s->rv10_first_dc_coded[component]) { | |
3785 diff = rv_decode_dc(s, n); | |
3786 if (diff == 0xffff) | |
3787 return -1; | |
3788 level += diff; | |
3789 level = level & 0xff; /* handle wrap round */ | |
3790 s->last_dc[component] = level; | |
3791 } else { | |
3792 s->rv10_first_dc_coded[component] = 1; | |
3793 } | |
1090 | 3794 } else { |
3795 level = get_bits(&s->gb, 8); | |
3796 } | |
3797 }else{ | |
0 | 3798 level = get_bits(&s->gb, 8); |
1089 | 3799 if((level&0x7F) == 0){ |
1090 | 3800 fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
1089 | 3801 return -1; |
3802 } | |
0 | 3803 if (level == 255) |
3804 level = 128; | |
3805 } | |
3806 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3807 i = 1; |
0 | 3808 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3809 i = 0; |
0 | 3810 } |
3811 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3812 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3813 goto not_coded; |
0 | 3814 s->block_last_index[n] = i - 1; |
3815 return 0; | |
3816 } | |
3817 | |
3818 for(;;) { | |
544 | 3819 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3820 if (code < 0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3821 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 3822 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3823 } |
0 | 3824 if (code == rl->n) { |
3825 /* escape */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3826 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3827 int is11 = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3828 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3829 run = get_bits(&s->gb, 6); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3830 if(is11){ |
1356 | 3831 level = get_sbits(&s->gb, 11); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3832 } else { |
1356 | 3833 level = get_sbits(&s->gb, 7); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3834 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3835 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3836 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3837 run = get_bits(&s->gb, 6); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3838 level = (int8_t)get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3839 if(level == -128){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3840 if (s->h263_rv10) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3841 /* XXX: should patch encoder too */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3842 level = get_sbits(&s->gb, 12); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3843 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3844 level = get_bits(&s->gb, 5); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3845 level |= get_sbits(&s->gb, 6)<<5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3846 } |
1089 | 3847 } |
0 | 3848 } |
3849 } else { | |
3850 run = rl->table_run[code]; | |
3851 level = rl->table_level[code]; | |
3852 last = code >= rl->last; | |
21 | 3853 if (get_bits1(&s->gb)) |
0 | 3854 level = -level; |
3855 } | |
3856 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3857 if (i >= 64){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3858 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y); |
0 | 3859 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3860 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3861 j = scan_table[i]; |
0 | 3862 block[j] = level; |
3863 if (last) | |
3864 break; | |
3865 i++; | |
3866 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3867 not_coded: |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3868 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3869 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
3870 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3871 } |
0 | 3872 s->block_last_index[n] = i; |
3873 return 0; | |
3874 } | |
3875 | |
1034 | 3876 /** |
3877 * decodes the dc value. | |
3878 * @param n block index (0-3 are luma, 4-5 are chroma) | |
3879 * @param dir_ptr the prediction direction will be stored here | |
3880 * @return the quantized dc | |
3881 */ | |
453 | 3882 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 3883 { |
3884 int level, pred, code; | |
1064 | 3885 uint16_t *dc_val; |
0 | 3886 |
3887 if (n < 4) | |
544 | 3888 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
0 | 3889 else |
544 | 3890 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 3891 if (code < 0 || code > 9 /* && s->nbit<9 */){ |
3892 fprintf(stderr, "illegal dc vlc\n"); | |
0 | 3893 return -1; |
453 | 3894 } |
0 | 3895 if (code == 0) { |
3896 level = 0; | |
3897 } else { | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3898 if(IS_3IV1){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3899 if(code==1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3900 level= 2*get_bits1(&s->gb)-1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3901 else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3902 if(get_bits1(&s->gb)) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3903 level = get_bits(&s->gb, code-1) + (1<<(code-1)); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3904 else |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3905 level = -get_bits(&s->gb, code-1) - (1<<(code-1)); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3906 } |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3907 }else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3908 level = get_xbits(&s->gb, code); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3909 } |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3910 |
453 | 3911 if (code > 8){ |
3912 if(get_bits1(&s->gb)==0){ /* marker */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3913 if(s->error_resilience>=2){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3914 fprintf(stderr, "dc marker bit missing\n"); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3915 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3916 } |
453 | 3917 } |
3918 } | |
0 | 3919 } |
498 | 3920 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
0 | 3921 level += pred; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3922 if (level < 0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3923 if(s->error_resilience>=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3924 fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3925 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3926 } |
0 | 3927 level = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3928 } |
0 | 3929 if (n < 4) { |
3930 *dc_val = level * s->y_dc_scale; | |
3931 } else { | |
3932 *dc_val = level * s->c_dc_scale; | |
3933 } | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3934 if(IS_3IV1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3935 *dc_val = level * 8; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3936 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3937 if(s->error_resilience>=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3938 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3939 fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3940 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3941 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3942 } |
0 | 3943 return level; |
3944 } | |
3945 | |
453 | 3946 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3947 * decodes a block. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3948 * @return <0 if an error occured |
453 | 3949 */ |
3950 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 3951 int n, int coded, int intra, int rvlc) |
0 | 3952 { |
549 | 3953 int level, i, last, run; |
0 | 3954 int dc_pred_dir; |
575 | 3955 RLTable * rl; |
3956 RL_VLC_ELEM * rl_vlc; | |
1064 | 3957 const uint8_t * scan_table; |
549 | 3958 int qmul, qadd; |
0 | 3959 |
1132 | 3960 //Note intra & rvlc should be optimized away if this is inlined |
3961 | |
575 | 3962 if(intra) { |
0 | 3963 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3964 if(s->partitioned_frame){ |
453 | 3965 level = s->dc_val[0][ s->block_index[n] ]; |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
3966 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
3967 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3968 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 3969 }else{ |
3970 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
3971 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3972 return -1; |
453 | 3973 } |
0 | 3974 block[0] = level; |
549 | 3975 i = 0; |
0 | 3976 if (!coded) |
3977 goto not_coded; | |
1132 | 3978 |
3979 if(rvlc){ | |
3980 rl = &rvlc_rl_intra; | |
3981 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
3982 }else{ | |
3983 rl = &rl_intra; | |
3984 rl_vlc = rl_intra.rl_vlc[0]; | |
3985 } | |
718 | 3986 if (s->ac_pred) { |
0 | 3987 if (dc_pred_dir == 0) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3988 scan_table = s->intra_v_scantable.permutated; /* left */ |
0 | 3989 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3990 scan_table = s->intra_h_scantable.permutated; /* top */ |
0 | 3991 } else { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3992 scan_table = s->intra_scantable.permutated; |
0 | 3993 } |
549 | 3994 qmul=1; |
3995 qadd=0; | |
0 | 3996 } else { |
549 | 3997 i = -1; |
0 | 3998 if (!coded) { |
549 | 3999 s->block_last_index[n] = i; |
0 | 4000 return 0; |
4001 } | |
1132 | 4002 if(rvlc) rl = &rvlc_rl_inter; |
4003 else rl = &rl_inter; | |
661 | 4004 |
718 | 4005 scan_table = s->intra_scantable.permutated; |
661 | 4006 |
591 | 4007 if(s->mpeg_quant){ |
4008 qmul=1; | |
4009 qadd=0; | |
1132 | 4010 if(rvlc){ |
4011 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
4012 }else{ | |
4013 rl_vlc = rl_inter.rl_vlc[0]; | |
4014 } | |
591 | 4015 }else{ |
4016 qmul = s->qscale << 1; | |
4017 qadd = (s->qscale - 1) | 1; | |
1132 | 4018 if(rvlc){ |
4019 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
4020 }else{ | |
4021 rl_vlc = rl_inter.rl_vlc[s->qscale]; | |
4022 } | |
591 | 4023 } |
0 | 4024 } |
549 | 4025 { |
4026 OPEN_READER(re, &s->gb); | |
0 | 4027 for(;;) { |
549 | 4028 UPDATE_CACHE(re, &s->gb); |
4029 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
4030 if (level==0) { | |
1132 | 4031 /* escape */ |
4032 if(rvlc){ | |
4033 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
4034 fprintf(stderr, "1. marker bit missing in rvlc esc\n"); | |
4035 return -1; | |
4036 }; SKIP_CACHE(re, &s->gb, 1); | |
4037 | |
4038 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4039 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4040 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
4041 UPDATE_CACHE(re, &s->gb); | |
4042 | |
4043 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
4044 fprintf(stderr, "2. marker bit missing in rvlc esc\n"); | |
4045 return -1; | |
4046 }; SKIP_CACHE(re, &s->gb, 1); | |
4047 | |
4048 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); | |
4049 | |
4050 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ | |
4051 fprintf(stderr, "reverse esc missing\n"); | |
4052 return -1; | |
4053 }; SKIP_CACHE(re, &s->gb, 5); | |
4054 | |
4055 level= level * qmul + qadd; | |
4056 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
4057 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
4058 | |
4059 i+= run + 1; | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4060 if(last) i+=192; |
1132 | 4061 }else{ |
549 | 4062 int cache; |
4063 cache= GET_CACHE(re, &s->gb); | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4064 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4065 if(IS_3IV1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4066 cache ^= 0xC0000000; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4067 |
549 | 4068 if (cache&0x80000000) { |
4069 if (cache&0x40000000) { | |
0 | 4070 /* third escape */ |
549 | 4071 SKIP_CACHE(re, &s->gb, 2); |
4072 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4073 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4074 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
4075 UPDATE_CACHE(re, &s->gb); | |
4076 | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4077 if(IS_3IV1){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4078 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4079 }else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4080 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4081 fprintf(stderr, "1. marker bit missing in 3. esc\n"); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4082 return -1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4083 }; SKIP_CACHE(re, &s->gb, 1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4084 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4085 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4086 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4087 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4088 fprintf(stderr, "2. marker bit missing in 3. esc\n"); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4089 return -1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4090 }; LAST_SKIP_CACHE(re, &s->gb, 1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4091 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4092 SKIP_COUNTER(re, &s->gb, 1+12+1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
4093 } |
549 | 4094 |
597 | 4095 if(level*s->qscale>1024 || level*s->qscale<-1024){ |
4096 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4097 return -1; |
453 | 4098 } |
4099 #if 1 | |
4100 { | |
4101 const int abs_level= ABS(level); | |
921 | 4102 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){ |
498 | 4103 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 4104 if(abs_level <= rl->max_level[last][run]){ |
4105 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n"); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4106 return -1; |
453 | 4107 } |
905
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4108 if(s->error_resilience > FF_ER_COMPLIANT){ |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4109 if(abs_level <= rl->max_level[last][run]*2){ |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4110 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n"); |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4111 return -1; |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4112 } |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4113 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4114 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n"); |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4115 return -1; |
2b93dc762f9a
fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents:
903
diff
changeset
|
4116 } |
453 | 4117 } |
4118 } | |
4119 } | |
4120 #endif | |
549 | 4121 if (level>0) level= level * qmul + qadd; |
4122 else level= level * qmul - qadd; | |
4123 | |
4124 i+= run + 1; | |
4125 if(last) i+=192; | |
0 | 4126 } else { |
4127 /* second escape */ | |
549 | 4128 #if MIN_CACHE_BITS < 20 |
4129 LAST_SKIP_BITS(re, &s->gb, 2); | |
4130 UPDATE_CACHE(re, &s->gb); | |
4131 #else | |
4132 SKIP_BITS(re, &s->gb, 2); | |
4133 #endif | |
4134 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
4135 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing | |
4136 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4137 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4138 } |
4139 } else { | |
4140 /* first escape */ | |
549 | 4141 #if MIN_CACHE_BITS < 19 |
4142 LAST_SKIP_BITS(re, &s->gb, 1); | |
4143 UPDATE_CACHE(re, &s->gb); | |
4144 #else | |
4145 SKIP_BITS(re, &s->gb, 1); | |
4146 #endif | |
4147 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
4148 i+= run; | |
4149 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4150 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4151 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4152 } |
1132 | 4153 } |
0 | 4154 } else { |
549 | 4155 i+= run; |
4156 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4157 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4158 } |
549 | 4159 if (i > 62){ |
4160 i-= 192; | |
4161 if(i&(~63)){ | |
4162 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4163 return -1; |
549 | 4164 } |
4165 | |
4166 block[scan_table[i]] = level; | |
0 | 4167 break; |
549 | 4168 } |
4169 | |
4170 block[scan_table[i]] = level; | |
0 | 4171 } |
549 | 4172 CLOSE_READER(re, &s->gb); |
4173 } | |
0 | 4174 not_coded: |
4175 if (s->mb_intra) { | |
4176 mpeg4_pred_ac(s, block, n, dc_pred_dir); | |
4177 if (s->ac_pred) { | |
549 | 4178 i = 63; /* XXX: not optimal */ |
0 | 4179 } |
4180 } | |
549 | 4181 s->block_last_index[n] = i; |
0 | 4182 return 0; |
4183 } | |
4184 | |
4185 /* most is hardcoded. should extend to handle all h263 streams */ | |
4186 int h263_decode_picture_header(MpegEncContext *s) | |
4187 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4188 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4189 uint32_t startcode; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4190 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4191 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4192 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4193 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4194 |
1393 | 4195 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) { |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4196 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4197 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4198 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4199 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4200 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4201 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4202 if (startcode != 0x20) { |
355 | 4203 fprintf(stderr, "Bad picture start code\n"); |
0 | 4204 return -1; |
355 | 4205 } |
4206 /* temporal reference */ | |
231 | 4207 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
355 | 4208 |
4209 /* PTYPE starts here */ | |
4210 if (get_bits1(&s->gb) != 1) { | |
4211 /* marker */ | |
4212 fprintf(stderr, "Bad marker\n"); | |
4213 return -1; | |
4214 } | |
4215 if (get_bits1(&s->gb) != 0) { | |
4216 fprintf(stderr, "Bad H263 id\n"); | |
0 | 4217 return -1; /* h263 id */ |
355 | 4218 } |
21 | 4219 skip_bits1(&s->gb); /* split screen off */ |
4220 skip_bits1(&s->gb); /* camera off */ | |
4221 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 4222 |
155
3c3449bce692
- Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents:
154
diff
changeset
|
4223 /* Reset GOB number */ |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
4224 s->gob_number = 0; |
155
3c3449bce692
- Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents:
154
diff
changeset
|
4225 |
0 | 4226 format = get_bits(&s->gb, 3); |
355 | 4227 /* |
4228 0 forbidden | |
4229 1 sub-QCIF | |
4230 10 QCIF | |
4231 7 extended PTYPE (PLUSPTYPE) | |
4232 */ | |
0 | 4233 |
161 | 4234 if (format != 7 && format != 6) { |
0 | 4235 s->h263_plus = 0; |
4236 /* H.263v1 */ | |
4237 width = h263_format[format][0]; | |
4238 height = h263_format[format][1]; | |
4239 if (!width) | |
4240 return -1; | |
161 | 4241 |
21 | 4242 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 4243 |
21 | 4244 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 4245 s->h263_long_vectors = s->unrestricted_mv; |
4246 | |
355 | 4247 if (get_bits1(&s->gb) != 0) { |
4248 fprintf(stderr, "H263 SAC not supported\n"); | |
0 | 4249 return -1; /* SAC: off */ |
355 | 4250 } |
161 | 4251 if (get_bits1(&s->gb) != 0) { |
4252 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
4253 } | |
4254 | |
355 | 4255 if (get_bits1(&s->gb) != 0) { |
4256 fprintf(stderr, "H263 PB frame not supported\n"); | |
0 | 4257 return -1; /* not PB frame */ |
355 | 4258 } |
0 | 4259 s->qscale = get_bits(&s->gb, 5); |
21 | 4260 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
1393 | 4261 |
4262 s->width = width; | |
4263 s->height = height; | |
0 | 4264 } else { |
161 | 4265 int ufep; |
4266 | |
0 | 4267 /* H.263v2 */ |
161 | 4268 s->h263_plus = 1; |
4269 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 4270 |
4271 /* ufep other than 0 and 1 are reserved */ | |
161 | 4272 if (ufep == 1) { |
4273 /* OPPTYPE */ | |
4274 format = get_bits(&s->gb, 3); | |
355 | 4275 dprintf("ufep=1, format: %d\n", format); |
161 | 4276 skip_bits(&s->gb,1); /* Custom PCF */ |
1089 | 4277 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */ |
161 | 4278 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */ |
4279 if (get_bits1(&s->gb) != 0) { | |
4280 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
4281 } | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4282 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4283 s->h263_aic = 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4284 } |
355 | 4285 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4286 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4287 fprintf(stderr, "Deblocking Filter not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4288 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4289 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4290 fprintf(stderr, "Slice Structured not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4291 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4292 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4293 fprintf(stderr, "Reference Picture Selection not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4294 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4295 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4296 fprintf(stderr, "Independent Segment Decoding not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4297 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4298 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4299 fprintf(stderr, "Alternative Inter VLC not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4300 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4301 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4302 fprintf(stderr, "Modified Quantization not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4303 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4304 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4305 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 4306 |
161 | 4307 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 4308 } else if (ufep != 0) { |
4309 fprintf(stderr, "Bad UFEP type (%d)\n", ufep); | |
0 | 4310 return -1; |
355 | 4311 } |
161 | 4312 |
78 | 4313 /* MPPTYPE */ |
355 | 4314 s->pict_type = get_bits(&s->gb, 3) + I_TYPE; |
4315 dprintf("pict_type: %d\n", s->pict_type); | |
0 | 4316 if (s->pict_type != I_TYPE && |
4317 s->pict_type != P_TYPE) | |
4318 return -1; | |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4319 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4320 s->no_rounding = get_bits1(&s->gb); |
355 | 4321 dprintf("RTYPE: %d\n", s->no_rounding); |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4322 skip_bits(&s->gb, 4); |
78 | 4323 |
4324 /* Get the picture dimensions */ | |
161 | 4325 if (ufep) { |
4326 if (format == 6) { | |
4327 /* Custom Picture Format (CPFMT) */ | |
355 | 4328 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4329 dprintf("aspect: %d\n", s->aspect_ratio_info); | |
4330 /* aspect ratios: | |
4331 0 - forbidden | |
4332 1 - 1:1 | |
4333 2 - 12:11 (CIF 4:3) | |
4334 3 - 10:11 (525-type 4:3) | |
4335 4 - 16:11 (CIF 16:9) | |
4336 5 - 40:33 (525-type 16:9) | |
4337 6-14 - reserved | |
4338 */ | |
161 | 4339 width = (get_bits(&s->gb, 9) + 1) * 4; |
4340 skip_bits1(&s->gb); | |
4341 height = get_bits(&s->gb, 9) * 4; | |
355 | 4342 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height); |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
4343 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 4344 /* aspected dimensions */ |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
4345 s->aspected_width = get_bits(&s->gb, 8); |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
4346 s->aspected_height = get_bits(&s->gb, 8); |
887 | 4347 }else{ |
4348 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0]; | |
4349 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1]; | |
355 | 4350 } |
4351 } else { | |
161 | 4352 width = h263_format[format][0]; |
4353 height = h263_format[format][1]; | |
4354 } | |
4355 if ((width == 0) || (height == 0)) | |
4356 return -1; | |
4357 s->width = width; | |
4358 s->height = height; | |
1089 | 4359 if (s->umvplus) { |
4360 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
4361 skip_bits1(&s->gb); | |
161 | 4362 } |
78 | 4363 } |
4364 | |
0 | 4365 s->qscale = get_bits(&s->gb, 5); |
4366 } | |
4367 /* PEI */ | |
21 | 4368 while (get_bits1(&s->gb) != 0) { |
4369 skip_bits(&s->gb, 8); | |
0 | 4370 } |
4371 s->f_code = 1; | |
498 | 4372 |
4373 if(s->h263_aic){ | |
4374 s->y_dc_scale_table= | |
4375 s->c_dc_scale_table= h263_aic_dc_scale_table; | |
4376 }else{ | |
4377 s->y_dc_scale_table= | |
4378 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
4379 } | |
4380 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4381 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4382 printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4383 s->qscale, av_get_pict_type_char(s->pict_type), |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4384 s->gb.size_in_bits, 1-s->no_rounding, |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4385 s->mv_type == MV_TYPE_8X8 ? "ADV" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4386 s->umvplus ? "UMV" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4387 s->h263_long_vectors ? "LONG" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4388 s->h263_plus ? "+" : "" |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4389 ); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4390 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4391 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4392 |
0 | 4393 return 0; |
4394 } | |
4395 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4396 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4397 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4398 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4399 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4400 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4401 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4402 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4403 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}}; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4404 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4405 int virtual_ref[2][2]; |
753 | 4406 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4407 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4408 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4409 int h= s->height; |
753 | 4410 int min_ab; |
4411 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4412 for(i=0; i<s->num_sprite_warping_points; i++){ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4413 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4414 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4415 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4416 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4417 if(length){ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
4418 x= get_xbits(&s->gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4419 } |
255 | 4420 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */ |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4421 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4422 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4423 if(length){ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
4424 y=get_xbits(&s->gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4425 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4426 skip_bits1(&s->gb); /* marker bit */ |
255 | 4427 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4428 d[i][0]= x; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4429 d[i][1]= y; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4430 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4431 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4432 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4433 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h' |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4434 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4435 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4436 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4437 // Note, the 4th point isnt used for GMC |
262 | 4438 if(s->divx_version==500 && s->divx_build==413){ |
4439 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
4440 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
4441 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
4442 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
4443 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
4444 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
4445 } else { | |
4446 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
4447 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
4448 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
4449 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
4450 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
4451 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
4452 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4453 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4454 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4455 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4456 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4457 // perhaps it should be reordered to be more readable ... |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4458 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4459 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4460 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 4461 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4462 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 4463 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4464 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 4465 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4466 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 4467 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h); |
753 | 4468 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4469 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4470 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4471 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4472 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4473 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4474 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4475 s->sprite_offset[1][1]= 0; |
753 | 4476 s->sprite_delta[0][0]= a; |
4477 s->sprite_delta[0][1]= 0; | |
4478 s->sprite_delta[1][0]= 0; | |
4479 s->sprite_delta[1][1]= a; | |
4480 s->sprite_shift[0]= 0; | |
4481 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4482 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4483 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4484 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4485 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4486 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4487 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 4488 s->sprite_delta[0][0]= a; |
4489 s->sprite_delta[0][1]= 0; | |
4490 s->sprite_delta[1][0]= 0; | |
4491 s->sprite_delta[1][1]= a; | |
4492 s->sprite_shift[0]= 0; | |
4493 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4494 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4495 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4496 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 4497 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
4498 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
4499 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4500 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 4501 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
4502 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
4503 + (1<<(alpha+rho-1)); | |
4504 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
4505 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
4506 +2*w2*r*sprite_ref[0][0] | |
4507 - 16*w2 | |
4508 + (1<<(alpha+rho+1))); | |
4509 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) | |
4510 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) | |
4511 +2*w2*r*sprite_ref[0][1] | |
4512 - 16*w2 | |
4513 + (1<<(alpha+rho+1))); | |
4514 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
4515 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
4516 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
4517 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
4518 | |
4519 s->sprite_shift[0]= alpha+rho; | |
4520 s->sprite_shift[1]= alpha+rho+2; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4521 break; |
753 | 4522 case 3: |
847 | 4523 min_ab= FFMIN(alpha, beta); |
753 | 4524 w3= w2>>min_ab; |
4525 h3= h2>>min_ab; | |
4526 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
4527 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
4528 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
4529 + (1<<(alpha+beta+rho-min_ab-1)); | |
4530 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
4531 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
4532 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
4533 + (1<<(alpha+beta+rho-min_ab-1)); | |
4534 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
4535 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
4536 + 2*w2*h3*r*sprite_ref[0][0] | |
4537 - 16*w2*h3 | |
4538 + (1<<(alpha+beta+rho-min_ab+1)); | |
4539 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
4540 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
4541 + 2*w2*h3*r*sprite_ref[0][1] | |
4542 - 16*w2*h3 | |
4543 + (1<<(alpha+beta+rho-min_ab+1)); | |
4544 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
4545 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
4546 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
4547 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
4548 | |
4549 s->sprite_shift[0]= alpha + beta + rho - min_ab; | |
4550 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4551 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4552 } |
255 | 4553 /* try to simplify the situation */ |
753 | 4554 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
4555 && s->sprite_delta[0][1] == 0 | |
4556 && s->sprite_delta[1][0] == 0 | |
4557 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 4558 { |
753 | 4559 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
4560 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
4561 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
4562 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
4563 s->sprite_delta[0][0]= a; | |
4564 s->sprite_delta[0][1]= 0; | |
4565 s->sprite_delta[1][0]= 0; | |
4566 s->sprite_delta[1][1]= a; | |
4567 s->sprite_shift[0]= 0; | |
4568 s->sprite_shift[1]= 0; | |
255 | 4569 s->real_sprite_warping_points=1; |
4570 } | |
753 | 4571 else{ |
4572 int shift_y= 16 - s->sprite_shift[0]; | |
4573 int shift_c= 16 - s->sprite_shift[1]; | |
4574 //printf("shifts %d %d\n", shift_y, shift_c); | |
4575 for(i=0; i<2; i++){ | |
4576 s->sprite_offset[0][i]<<= shift_y; | |
4577 s->sprite_offset[1][i]<<= shift_c; | |
4578 s->sprite_delta[0][i]<<= shift_y; | |
4579 s->sprite_delta[1][i]<<= shift_y; | |
4580 s->sprite_shift[i]= 16; | |
4581 } | |
255 | 4582 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 4583 } |
4584 #if 0 | |
4585 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", | |
4586 vop_ref[0][0], vop_ref[0][1], | |
4587 vop_ref[1][0], vop_ref[1][1], | |
4588 vop_ref[2][0], vop_ref[2][1], | |
4589 sprite_ref[0][0], sprite_ref[0][1], | |
4590 sprite_ref[1][0], sprite_ref[1][1], | |
4591 sprite_ref[2][0], sprite_ref[2][1], | |
4592 virtual_ref[0][0], virtual_ref[0][1], | |
4593 virtual_ref[1][0], virtual_ref[1][1] | |
4594 ); | |
4595 | |
4596 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", | |
4597 s->sprite_offset[0][0], s->sprite_offset[0][1], | |
4598 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
4599 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
4600 s->sprite_shift[0] | |
4601 ); | |
4602 #endif | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4603 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4604 |
942 | 4605 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
4606 int hours, minutes, seconds; | |
4607 | |
4608 hours= get_bits(gb, 5); | |
4609 minutes= get_bits(gb, 6); | |
4610 skip_bits1(gb); | |
4611 seconds= get_bits(gb, 6); | |
4612 | |
4613 s->time_base= seconds + 60*(minutes + 60*hours); | |
4614 | |
4615 skip_bits1(gb); | |
4616 skip_bits1(gb); | |
4617 | |
4618 return 0; | |
4619 } | |
4620 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4621 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4622 int width, height, vo_ver_id; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4623 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4624 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4625 skip_bits(gb, 1); /* random access */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4626 s->vo_type= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4627 if (get_bits1(gb) != 0) { /* is_ol_id */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4628 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4629 skip_bits(gb, 3); /* vo_priority */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4630 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4631 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4632 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4633 //printf("vo type:%d\n",s->vo_type); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4634 s->aspect_ratio_info= get_bits(gb, 4); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4635 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4636 s->aspected_width = get_bits(gb, 8); // par_width |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4637 s->aspected_height = get_bits(gb, 8); // par_height |
887 | 4638 }else{ |
4639 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0]; | |
4640 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1]; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4641 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4642 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4643 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4644 int chroma_format= get_bits(gb, 2); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4645 if(chroma_format!=1){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4646 printf("illegal chroma format\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4647 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4648 s->low_delay= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4649 if(get_bits1(gb)){ /* vbv parameters */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4650 get_bits(gb, 15); /* first_half_bitrate */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4651 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4652 get_bits(gb, 15); /* latter_half_bitrate */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4653 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4654 get_bits(gb, 15); /* first_half_vbv_buffer_size */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4655 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4656 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4657 get_bits(gb, 11); /* first_half_vbv_occupancy */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4658 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4659 get_bits(gb, 15); /* latter_half_vbv_occupancy */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4660 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4661 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4662 }else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4663 // set low delay flag only once so the smart? low delay detection wont be overriden |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4664 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4665 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4666 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4667 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4668 s->shape = get_bits(gb, 2); /* vol shape */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4669 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4670 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4671 printf("Gray shape not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4672 skip_bits(gb, 4); //video_object_layer_shape_extension |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4673 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4674 |
1411 | 4675 check_marker(gb, "before time_increment_resolution"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4676 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4677 s->time_increment_resolution = get_bits(gb, 16); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4678 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4679 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4680 if (s->time_increment_bits < 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4681 s->time_increment_bits = 1; |
1411 | 4682 |
4683 check_marker(gb, "before fixed_vop_rate"); | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4684 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4685 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4686 skip_bits(gb, s->time_increment_bits); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4687 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4688 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4689 if (s->shape != BIN_ONLY_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4690 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4691 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4692 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4693 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4694 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4695 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4696 if(width && height){ /* they should be non zero but who knows ... */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4697 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4698 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4699 // printf("width/height: %d %d\n", width, height); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4700 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4701 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4702 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4703 s->progressive_sequence= get_bits1(gb)^1; |
1237 | 4704 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
4705 printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4706 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4707 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4708 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4709 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4710 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4711 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4712 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4713 if(s->vol_sprite_usage==STATIC_SPRITE){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4714 s->sprite_width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4715 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4716 s->sprite_height= get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4717 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4718 s->sprite_left = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4719 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4720 s->sprite_top = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4721 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4722 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4723 s->num_sprite_warping_points= get_bits(gb, 6); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4724 s->sprite_warping_accuracy = get_bits(gb, 2); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4725 s->sprite_brightness_change= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4726 if(s->vol_sprite_usage==STATIC_SPRITE) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4727 s->low_latency_sprite= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4728 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4729 // FIXME sadct disable bit if verid!=1 && shape not rect |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4730 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4731 if (get_bits1(gb) == 1) { /* not_8_bit */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4732 s->quant_precision = get_bits(gb, 4); /* quant_precision */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4733 if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4734 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4735 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4736 s->quant_precision = 5; |
0 | 4737 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4738 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4739 // FIXME a bunch of grayscale shape things |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4740 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4741 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 4742 int i, v; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4743 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4744 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4745 for(i=0; i<64; i++){ |
1092 | 4746 int j= s->dsp.idct_permutation[i]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4747 v= ff_mpeg4_default_intra_matrix[i]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4748 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4749 s->chroma_intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4750 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4751 v= ff_mpeg4_default_non_intra_matrix[i]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4752 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4753 s->chroma_inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4754 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4755 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4756 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4757 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4758 int last=0; |
1057 | 4759 for(i=0; i<64; i++){ |
4760 int j; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4761 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4762 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4763 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4764 last= v; |
1092 | 4765 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4766 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4767 s->chroma_intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4768 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4769 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4770 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4771 for(; i<64; i++){ |
1092 | 4772 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
1411 | 4773 s->intra_matrix[j]= last; |
4774 s->chroma_intra_matrix[j]= last; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4775 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4776 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4777 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4778 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4779 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4780 int last=0; |
1057 | 4781 for(i=0; i<64; i++){ |
4782 int j; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4783 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4784 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4785 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4786 last= v; |
1092 | 4787 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4788 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4789 s->chroma_inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4790 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4791 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4792 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4793 for(; i<64; i++){ |
1092 | 4794 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4795 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4796 s->chroma_inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4797 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4798 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4799 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4800 // FIXME a bunch of grayscale shape things |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4801 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4802 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4803 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4804 s->quarter_sample= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4805 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4806 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4807 if(!get_bits1(gb)) printf("Complexity estimation not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4808 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4809 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4810 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4811 s->data_partitioning= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4812 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4813 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4814 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4815 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4816 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4817 s->new_pred= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4818 if(s->new_pred){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4819 printf("new pred not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4820 skip_bits(gb, 2); /* requested upstream message type */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4821 skip_bits1(gb); /* newpred segment type */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4822 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4823 s->reduced_res_vop= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4824 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4825 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4826 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4827 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4828 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4829 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4830 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4831 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4832 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4833 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4834 GetBitContext bak= *gb; |
751 | 4835 int ref_layer_id; |
4836 int ref_layer_sampling_dir; | |
4837 int h_sampling_factor_n; | |
4838 int h_sampling_factor_m; | |
4839 int v_sampling_factor_n; | |
4840 int v_sampling_factor_m; | |
4841 | |
4842 s->hierachy_type= get_bits1(gb); | |
4843 ref_layer_id= get_bits(gb, 4); | |
4844 ref_layer_sampling_dir= get_bits1(gb); | |
4845 h_sampling_factor_n= get_bits(gb, 5); | |
4846 h_sampling_factor_m= get_bits(gb, 5); | |
4847 v_sampling_factor_n= get_bits(gb, 5); | |
4848 v_sampling_factor_m= get_bits(gb, 5); | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4849 s->enhancement_type= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4850 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4851 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4852 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4853 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4854 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4855 s->scalability=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4856 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4857 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4858 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4859 printf("scalability not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4860 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4861 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4862 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4863 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4864 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4865 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4866 |
1034 | 4867 /** |
4868 * decodes the user data stuff in the header. | |
4869 * allso inits divx/xvid/lavc_version/build | |
4870 */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4871 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4872 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4873 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4874 int e; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4875 int ver, build, ver2, ver3; |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
4876 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4877 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4878 buf[0]= show_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4879 for(i=1; i<256; i++){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4880 buf[i]= show_bits(gb, 16)&0xFF; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4881 if(buf[i]==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4882 skip_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4883 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4884 buf[255]=0; |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
4885 |
761 | 4886 /* divx detection */ |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
4887 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last); |
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
4888 if(e<2) |
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
4889 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last); |
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
4890 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4891 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4892 s->divx_build= build; |
1145
79e8ed620b17
better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents:
1144
diff
changeset
|
4893 s->divx_packed= e==3 && last=='p'; |
0 | 4894 } |
761 | 4895 |
4896 /* ffmpeg detection */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4897 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4898 if(e!=4) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4899 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4900 if(e!=4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4901 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4902 s->ffmpeg_version= 0x000406; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4903 s->lavc_build= 4600; |
63 | 4904 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4905 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4906 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4907 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4908 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4909 } |
761 | 4910 |
4911 /* xvid detection */ | |
4912 e=sscanf(buf, "XviD%d", &build); | |
4913 if(e==1){ | |
4914 s->xvid_build= build; | |
4915 } | |
4916 | |
255 | 4917 //printf("User Data: %s\n", buf); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4918 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4919 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4920 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4921 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4922 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4923 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4924 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ |
1346 | 4925 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4926 printf("low_delay flag set, but shouldnt, clearing it\n"); |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4927 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4928 } |
753 | 4929 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4930 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4931 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4932 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4933 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4934 s->decode_mb= ff_h263_decode_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4935 |
662
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4936 if(s->time_increment_resolution==0){ |
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4937 s->time_increment_resolution=1; |
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4938 // fprintf(stderr, "time_increment_resolution is illegal\n"); |
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4939 } |
262 | 4940 time_incr=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4941 while (get_bits1(gb) != 0) |
0 | 4942 time_incr++; |
4943 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4944 check_marker(gb, "before time_increment"); |
1068 | 4945 |
1396 | 4946 if(s->time_increment_bits==0){ |
1068 | 4947 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n"); |
4948 | |
4949 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
4950 if(show_bits(gb, s->time_increment_bits+1)&1) break; | |
4951 } | |
1396 | 4952 |
1068 | 4953 printf("my guess is %d bits ;)\n",s->time_increment_bits); |
4954 } | |
4955 | |
1411 | 4956 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further |
4957 else time_increment= get_bits(gb, s->time_increment_bits); | |
4958 | |
4959 // printf("%d %X\n", s->time_increment_bits, time_increment); | |
697 | 4960 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment); |
262 | 4961 if(s->pict_type!=B_TYPE){ |
324 | 4962 s->last_time_base= s->time_base; |
262 | 4963 s->time_base+= time_incr; |
324 | 4964 s->time= s->time_base*s->time_increment_resolution + time_increment; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4965 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4966 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4967 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n"); |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4968 s->time_base++; |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4969 s->time+= s->time_increment_resolution; |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4970 } |
664 | 4971 } |
324 | 4972 s->pp_time= s->time - s->last_non_b_time; |
4973 s->last_non_b_time= s->time; | |
262 | 4974 }else{ |
324 | 4975 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment; |
664 | 4976 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
4977 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
335 | 4978 // printf("messed up order, seeking?, skiping current b frame\n"); |
4979 return FRAME_SKIPED; | |
4980 } | |
664 | 4981 |
4982 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base; | |
4983 if(s->t_frame==0) s->t_frame=1; // 1/0 protection | |
4984 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout); | |
4985 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) | |
4986 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
4987 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) | |
4988 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
262 | 4989 } |
654 | 4990 |
903 | 4991 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution; |
942 | 4992 if(s->avctx->debug&FF_DEBUG_PTS) |
4993 printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0)); | |
654 | 4994 |
1068 | 4995 check_marker(gb, "before vop_coded"); |
4996 | |
0 | 4997 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4998 if (get_bits1(gb) != 1){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4999 printf("vop not coded\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5000 return FRAME_SKIPED; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5001 } |
664 | 5002 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base, |
5003 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time); | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5004 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5005 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { |
0 | 5006 /* rounding type for motion estimation */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5007 s->no_rounding = get_bits1(gb); |
63 | 5008 } else { |
5009 s->no_rounding = 0; | |
0 | 5010 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5011 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5012 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5013 if (s->shape != RECT_SHAPE) { |
63 | 5014 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { |
5015 int width, height, hor_spat_ref, ver_spat_ref; | |
5016 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5017 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5018 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5019 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5020 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5021 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5022 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5023 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 5024 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5025 skip_bits1(gb); /* change_CR_disable */ |
63 | 5026 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5027 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5028 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 5029 } |
5030 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5031 //FIXME complexity estimation stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5032 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5033 if (s->shape != BIN_ONLY_SHAPE) { |
290 | 5034 int t; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5035 t=get_bits(gb, 3); /* intra dc VLC threshold */ |
290 | 5036 //printf("threshold %d\n", t); |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
5037 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5038 s->top_field_first= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5039 s->alternate_scan= get_bits1(gb); |
661 | 5040 }else |
5041 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5042 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5043 |
718 | 5044 if(s->alternate_scan){ |
1273 | 5045 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
5046 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
5047 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
5048 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5049 } else{ |
1273 | 5050 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
5051 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
5052 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
5053 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5054 } |
5055 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5056 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
821 | 5057 mpeg4_decode_sprite_trajectory(s); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5058 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5059 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n"); |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5060 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5061 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5062 if (s->shape != BIN_ONLY_SHAPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5063 s->qscale = get_bits(gb, s->quant_precision); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5064 if(s->qscale==0){ |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5065 printf("Error, header damaged or not MPEG4 header (qscale=0)\n"); |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5066 return -1; // makes no sense to continue, as there is nothing left from the image then |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5067 } |
63 | 5068 |
5069 if (s->pict_type != I_TYPE) { | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5070 s->f_code = get_bits(gb, 3); /* fcode_for */ |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5071 if(s->f_code==0){ |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5072 printf("Error, header damaged or not MPEG4 header (f_code=0)\n"); |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5073 return -1; // makes no sense to continue, as the MV decoding will break very quickly |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5074 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5075 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5076 s->f_code=1; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5077 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5078 if (s->pict_type == B_TYPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5079 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5080 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5081 s->b_code=1; |
906 | 5082 |
5083 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1457 | 5084 printf("qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s\n", |
906 | 5085 s->qscale, s->f_code, s->b_code, |
5086 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")), | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
5087 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, |
930 | 5088 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, |
1457 | 5089 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " "); |
906 | 5090 } |
5091 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5092 if(!s->scalability){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5093 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5094 skip_bits1(gb); // vop shape coding type |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5095 } |
575 | 5096 }else{ |
5097 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5098 int load_backward_shape= get_bits1(gb); |
575 | 5099 if(load_backward_shape){ |
5100 printf("load backward shape isnt supported\n"); | |
5101 } | |
5102 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5103 skip_bits(gb, 2); //ref_select_code |
63 | 5104 } |
5105 } | |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5106 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/ |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5107 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too) |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5108 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){ |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5109 printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n"); |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5110 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5111 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5112 |
255 | 5113 s->picture_number++; // better than pic number==0 allways ;) |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5114 |
498 | 5115 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
5116 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
5117 | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1364
diff
changeset
|
5118 if(s->workaround_bugs&FF_BUG_EDGE){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5119 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5120 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5121 } |
63 | 5122 return 0; |
0 | 5123 } |
5124 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5125 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5126 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5127 * @return <0 if no VOP found (or a damaged one) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5128 * FRAME_SKIPPED if a not coded VOP is found |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5129 * 0 if a VOP is found |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5130 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5131 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5132 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5133 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5134 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5135 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5136 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5137 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5138 for(;;) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5139 v = get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5140 startcode = ((startcode << 8) | v) & 0xffffffff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5141 |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
5142 if(get_bits_count(gb) >= gb->size_in_bits){ |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
5143 if(gb->size_in_bits==8 && s->divx_version){ |
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
1013
diff
changeset
|
5144 printf("frame skip %d\n", gb->size_in_bits); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5145 return FRAME_SKIPED; //divx bug |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5146 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5147 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5148 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5149 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5150 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5151 continue; //no startcode |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5152 |
942 | 5153 if(s->avctx->debug&FF_DEBUG_STARTCODE){ |
5154 printf("startcode: %3X ", startcode); | |
5155 if (startcode<=0x11F) printf("Video Object Start"); | |
5156 else if(startcode<=0x12F) printf("Video Object Layer Start"); | |
5157 else if(startcode<=0x13F) printf("Reserved"); | |
5158 else if(startcode<=0x15F) printf("FGS bp start"); | |
5159 else if(startcode<=0x1AF) printf("Reserved"); | |
5160 else if(startcode==0x1B0) printf("Visual Object Seq Start"); | |
5161 else if(startcode==0x1B1) printf("Visual Object Seq End"); | |
5162 else if(startcode==0x1B2) printf("User Data"); | |
5163 else if(startcode==0x1B3) printf("Group of VOP start"); | |
5164 else if(startcode==0x1B4) printf("Video Session Error"); | |
5165 else if(startcode==0x1B5) printf("Visual Object Start"); | |
5166 else if(startcode==0x1B6) printf("Video Object Plane start"); | |
5167 else if(startcode==0x1B7) printf("slice start"); | |
5168 else if(startcode==0x1B8) printf("extension start"); | |
5169 else if(startcode==0x1B9) printf("fgs start"); | |
5170 else if(startcode==0x1BA) printf("FBA Object start"); | |
5171 else if(startcode==0x1BB) printf("FBA Object Plane start"); | |
5172 else if(startcode==0x1BC) printf("Mesh Object start"); | |
5173 else if(startcode==0x1BD) printf("Mesh Object Plane start"); | |
5174 else if(startcode==0x1BE) printf("Still Textutre Object start"); | |
5175 else if(startcode==0x1BF) printf("Textutre Spatial Layer start"); | |
5176 else if(startcode==0x1C0) printf("Textutre SNR Layer start"); | |
5177 else if(startcode==0x1C1) printf("Textutre Tile start"); | |
5178 else if(startcode==0x1C2) printf("Textutre Shape Layer start"); | |
5179 else if(startcode==0x1C3) printf("stuffing start"); | |
5180 else if(startcode<=0x1C5) printf("reserved"); | |
5181 else if(startcode<=0x1FF) printf("System start"); | |
5182 printf(" at %d\n", get_bits_count(gb)); | |
5183 } | |
5184 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5185 switch(startcode){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5186 case 0x120: |
1396 | 5187 if(decode_vol_header(s, gb) < 0) |
5188 return -1; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5189 break; |
942 | 5190 case USER_DATA_STARTCODE: |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5191 decode_user_data(s, gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5192 break; |
942 | 5193 case GOP_STARTCODE: |
5194 mpeg4_decode_gop_header(s, gb); | |
5195 break; | |
5196 case VOP_STARTCODE: | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5197 return decode_vop_header(s, gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5198 default: |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5199 break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5200 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5201 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5202 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5203 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5204 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5205 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5206 |
0 | 5207 /* don't understand why they choose a different header ! */ |
5208 int intel_h263_decode_picture_header(MpegEncContext *s) | |
5209 { | |
5210 int format; | |
5211 | |
5212 /* picture header */ | |
1257 | 5213 if (get_bits_long(&s->gb, 22) != 0x20) { |
355 | 5214 fprintf(stderr, "Bad picture start code\n"); |
0 | 5215 return -1; |
355 | 5216 } |
5217 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 5218 |
355 | 5219 if (get_bits1(&s->gb) != 1) { |
5220 fprintf(stderr, "Bad marker\n"); | |
0 | 5221 return -1; /* marker */ |
355 | 5222 } |
5223 if (get_bits1(&s->gb) != 0) { | |
5224 fprintf(stderr, "Bad H263 id\n"); | |
0 | 5225 return -1; /* h263 id */ |
355 | 5226 } |
21 | 5227 skip_bits1(&s->gb); /* split screen off */ |
5228 skip_bits1(&s->gb); /* camera off */ | |
5229 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 5230 |
5231 format = get_bits(&s->gb, 3); | |
355 | 5232 if (format != 7) { |
5233 fprintf(stderr, "Intel H263 free format not supported\n"); | |
0 | 5234 return -1; |
355 | 5235 } |
0 | 5236 s->h263_plus = 0; |
5237 | |
21 | 5238 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 5239 |
21 | 5240 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 5241 s->h263_long_vectors = s->unrestricted_mv; |
5242 | |
355 | 5243 if (get_bits1(&s->gb) != 0) { |
5244 fprintf(stderr, "SAC not supported\n"); | |
0 | 5245 return -1; /* SAC: off */ |
355 | 5246 } |
5247 if (get_bits1(&s->gb) != 0) { | |
5248 fprintf(stderr, "Advanced Prediction Mode not supported\n"); | |
0 | 5249 return -1; /* advanced prediction mode: off */ |
355 | 5250 } |
5251 if (get_bits1(&s->gb) != 0) { | |
5252 fprintf(stderr, "PB frame mode no supported\n"); | |
5253 return -1; /* PB frame mode */ | |
5254 } | |
0 | 5255 |
5256 /* skip unknown header garbage */ | |
21 | 5257 skip_bits(&s->gb, 41); |
0 | 5258 |
5259 s->qscale = get_bits(&s->gb, 5); | |
21 | 5260 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 5261 |
5262 /* PEI */ | |
21 | 5263 while (get_bits1(&s->gb) != 0) { |
5264 skip_bits(&s->gb, 8); | |
0 | 5265 } |
5266 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5267 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5268 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5269 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5270 |
0 | 5271 return 0; |
5272 } | |
144 | 5273 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5274 int flv_h263_decode_picture_header(MpegEncContext *s) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5275 { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5276 int format, width, height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5277 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5278 /* picture header */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5279 if (get_bits_long(&s->gb, 17) != 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5280 fprintf(stderr, "Bad picture start code\n"); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5281 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5282 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5283 format = get_bits(&s->gb, 5); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5284 if (format != 0 && format != 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5285 fprintf(stderr, "Bad picture format\n"); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5286 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5287 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5288 s->h263_flv = format+1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5289 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5290 format = get_bits(&s->gb, 3); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5291 switch (format) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5292 case 0: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5293 width = get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5294 height = get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5295 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5296 case 1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5297 width = get_bits(&s->gb, 16); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5298 height = get_bits(&s->gb, 16); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5299 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5300 case 2: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5301 width = 352; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5302 height = 288; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5303 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5304 case 3: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5305 width = 176; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5306 height = 144; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5307 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5308 case 4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5309 width = 128; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5310 height = 96; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5311 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5312 case 5: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5313 width = 320; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5314 height = 240; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5315 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5316 case 6: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5317 width = 160; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5318 height = 120; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5319 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5320 default: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5321 width = height = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5322 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5323 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5324 if ((width == 0) || (height == 0)) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5325 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5326 s->width = width; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5327 s->height = height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5328 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5329 s->pict_type = I_TYPE + get_bits(&s->gb, 2); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5330 if (s->pict_type > P_TYPE) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5331 s->pict_type = P_TYPE; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5332 skip_bits1(&s->gb); /* deblocking flag */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5333 s->qscale = get_bits(&s->gb, 5); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5334 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5335 s->h263_plus = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5336 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5337 s->unrestricted_mv = 1; |
1364 | 5338 s->h263_long_vectors = 0; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5339 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5340 /* PEI */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5341 while (get_bits1(&s->gb) != 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5342 skip_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5343 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5344 s->f_code = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5345 |
1364 | 5346 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ |
5347 printf("%c esc_type:%d, qp:%d num:%d\n", | |
5348 av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); | |
5349 } | |
5350 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5351 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5352 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5353 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5354 return 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5355 } |