Mercurial > libavcodec.hg
annotate h263.c @ 8708:2ecdf1ad277f libavcodec
Cosmetics: simplifying static initialization
author | romansh |
---|---|
date | Sat, 31 Jan 2009 01:41:04 +0000 |
parents | 25aa5388fa97 |
children | e9d9d946f213 |
rev | line source |
---|---|
0 | 1 /* |
2 * H263/MPEG4 backend for ffmpeg encoder and decoder | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8627
diff
changeset
|
3 * Copyright (c) 2000,2001 Fabrice Bellard |
78 | 4 * H263+ support. |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8627
diff
changeset
|
5 * Copyright (c) 2001 Juan J. Sierralta P |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1708
diff
changeset
|
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 7 * |
5214 | 8 * ac prediction encoding, B-frame support, error resilience, optimizations, |
9 * qpel decoding, gmc decoding, interlaced decoding | |
10 * by Michael Niedermayer <michaelni@gmx.at> | |
11 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
12 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
13 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
14 * FFmpeg is free software; you can redistribute it and/or |
429 | 15 * modify it under the terms of the GNU Lesser General Public |
16 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
17 * version 2.1 of the License, or (at your option) any later version. |
0 | 18 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
19 * FFmpeg is distributed in the hope that it will be useful, |
0 | 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
22 * Lesser General Public License for more details. | |
0 | 23 * |
429 | 24 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
25 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3024
diff
changeset
|
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 27 */ |
1034 | 28 |
29 /** | |
30 * @file h263.c | |
1106 | 31 * h263/mpeg4 codec. |
1034 | 32 */ |
2967 | 33 |
355 | 34 //#define DEBUG |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
35 #include <limits.h> |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
36 |
0 | 37 #include "dsputil.h" |
38 #include "avcodec.h" | |
39 #include "mpegvideo.h" | |
40 #include "h263data.h" | |
41 #include "mpeg4data.h" | |
8627
d6bab465b82c
moves mid_pred() into mathops.h (with arch specific code split by directory)
aurel
parents:
8612
diff
changeset
|
42 #include "mathops.h" |
0 | 43 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
44 //#undef NDEBUG |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
45 //#include <assert.h> |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
46 |
544 | 47 #define INTRA_MCBPC_VLC_BITS 6 |
1482 | 48 #define INTER_MCBPC_VLC_BITS 7 |
544 | 49 #define CBPY_VLC_BITS 6 |
50 #define MV_VLC_BITS 9 | |
51 #define DC_VLC_BITS 9 | |
52 #define SPRITE_TRAJ_VLC_BITS 6 | |
53 #define MB_TYPE_B_VLC_BITS 4 | |
54 #define TEX_VLC_BITS 9 | |
1655 | 55 #define H263_MBTYPE_B_VLC_BITS 6 |
56 #define CBPC_B_VLC_BITS 3 | |
544 | 57 |
8590 | 58 #if CONFIG_ENCODERS |
0 | 59 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
|
60 int n); |
78 | 61 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
|
62 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
2967 | 63 int n, int dc, uint8_t *scan_table, |
453 | 64 PutBitContext *dc_pb, PutBitContext *ac_pb); |
3777 | 65 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
66 uint8_t *scan_table); | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
67 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
68 |
262 | 69 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 70 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 71 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
72 int n, int coded); | |
453 | 73 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
74 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 75 int n, int coded, int intra, int rvlc); |
8590 | 76 #if CONFIG_ENCODERS |
3781 | 77 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr); |
1424 | 78 static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
79 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
|
80 #endif //CONFIG_ENCODERS |
1914 | 81 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); |
2003 | 82 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding); |
1064 | 83 |
8590 | 84 #if CONFIG_ENCODERS |
1064 | 85 static uint8_t uni_DCtab_lum_len[512]; |
86 static uint8_t uni_DCtab_chrom_len[512]; | |
87 static uint16_t uni_DCtab_lum_bits[512]; | |
88 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
|
89 |
4655 | 90 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
1064 | 91 static uint8_t fcode_tab[MAX_MV*2+1]; |
92 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
|
93 |
945 | 94 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
95 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
96 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
97 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
2253 | 98 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; |
99 static uint8_t uni_h263_inter_rl_len [64*64*2*2]; | |
945 | 100 //#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
|
101 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 102 #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
|
103 |
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 /* 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
|
105 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
|
106 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
|
107 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
|
108 |
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
|
109 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
|
110 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
|
111 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
|
112 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
113 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
114 |
4672 | 115 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3]; |
116 | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
117 #if 0 //3IV1 is quite rare and it slows things down a tiny bit |
8612 | 118 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1") |
2967 | 119 #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
|
120 #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
|
121 #endif |
293 | 122 |
0 | 123 int h263_get_picture_format(int width, int height) |
124 { | |
125 int format; | |
126 | |
127 if (width == 128 && height == 96) | |
355 | 128 format = 1; |
0 | 129 else if (width == 176 && height == 144) |
355 | 130 format = 2; |
0 | 131 else if (width == 352 && height == 288) |
355 | 132 format = 3; |
0 | 133 else if (width == 704 && height == 576) |
355 | 134 format = 4; |
0 | 135 else if (width == 1408 && height == 1152) |
355 | 136 format = 5; |
0 | 137 else |
138 format = 7; | |
139 return format; | |
140 } | |
141 | |
5403 | 142 static void show_pict_info(MpegEncContext *s){ |
143 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n", | |
144 s->qscale, av_get_pict_type_char(s->pict_type), | |
145 s->gb.size_in_bits, 1-s->no_rounding, | |
146 s->obmc ? " AP" : "", | |
147 s->umvplus ? " UMV" : "", | |
148 s->h263_long_vectors ? " LONG" : "", | |
149 s->h263_plus ? " +" : "", | |
150 s->h263_aic ? " AIC" : "", | |
151 s->alt_inter_vlc ? " AIV" : "", | |
152 s->modified_quant ? " MQ" : "", | |
153 s->loop_filter ? " LOOP" : "", | |
154 s->h263_slice_structured ? " SS" : "", | |
155 s->avctx->time_base.den, s->avctx->time_base.num | |
156 ); | |
157 } | |
158 | |
8590 | 159 #if CONFIG_ENCODERS |
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
|
160 |
1548 | 161 static void aspect_to_info(MpegEncContext * s, AVRational aspect){ |
887 | 162 int i; |
163 | |
1548 | 164 if(aspect.num==0) aspect= (AVRational){1,1}; |
165 | |
887 | 166 for(i=1; i<6; i++){ |
1548 | 167 if(av_cmp_q(pixel_aspect[i], aspect) == 0){ |
887 | 168 s->aspect_ratio_info=i; |
169 return; | |
170 } | |
171 } | |
2967 | 172 |
887 | 173 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 174 } |
175 | |
1354 | 176 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
0 | 177 { |
1354 | 178 int format; |
179 | |
180 align_put_bits(&s->pb); | |
181 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
182 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
|
183 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ |
2637 | 184 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp |
185 s->avctx->time_base.den) & 0xff); /* TemporalReference */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
186 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
|
187 format = 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
188 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
|
189 format = 3; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
190 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
|
191 format = 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
192 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
|
193 format = 5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
194 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
|
195 format = 6; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
196 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
|
197 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
|
198 else |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
199 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
|
200 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
|
201 if (format == 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
202 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
|
203 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
|
204 } else if (format == 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
205 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
|
206 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
|
207 } |
6481 | 208 put_bits(&s->pb, 2, s->pict_type == FF_P_TYPE); /* PictureType */ |
1390
39d07c0263de
patch for flv deblocking by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1389
diff
changeset
|
209 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
|
210 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
|
211 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
|
212 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
213 if(s->h263_aic){ |
2967 | 214 s->y_dc_scale_table= |
1639 | 215 s->c_dc_scale_table= ff_aic_dc_scale_table; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
216 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
217 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
218 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
|
219 } |
1354 | 220 } |
221 | |
222 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
223 { | |
1872 | 224 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref; |
225 int best_clock_code=1; | |
226 int best_divisor=60; | |
227 int best_error= INT_MAX; | |
2967 | 228 |
1872 | 229 if(s->h263_plus){ |
230 for(i=0; i<2; i++){ | |
231 int div, error; | |
2637 | 232 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den); |
5075
33d50e0e1823
Correct the parameter order for the call to "av_clip".
takis
parents:
4984
diff
changeset
|
233 div= av_clip(div, 1, 127); |
4001 | 234 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div); |
1872 | 235 if(error < best_error){ |
236 best_error= error; | |
237 best_divisor= div; | |
238 best_clock_code= i; | |
239 } | |
240 } | |
241 } | |
242 s->custom_pcf= best_clock_code!=1 || best_divisor!=60; | |
243 coded_frame_rate= 1800000; | |
244 coded_frame_rate_base= (1000+best_clock_code)*best_divisor; | |
1354 | 245 |
246 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
|
247 |
231 | 248 /* 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
|
249 s->ptr_lastgob = pbBufPtr(&s->pb); |
231 | 250 put_bits(&s->pb, 22, 0x20); /* PSC */ |
2637 | 251 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp |
252 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
253 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */ |
0 | 254 |
2979 | 255 put_bits(&s->pb, 1, 1); /* marker */ |
256 put_bits(&s->pb, 1, 0); /* h263 id */ | |
257 put_bits(&s->pb, 1, 0); /* split screen off */ | |
258 put_bits(&s->pb, 1, 0); /* camera off */ | |
259 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
2967 | 260 |
78 | 261 format = h263_get_picture_format(s->width, s->height); |
0 | 262 if (!s->h263_plus) { |
263 /* H.263v1 */ | |
264 put_bits(&s->pb, 3, format); | |
6481 | 265 put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE)); |
0 | 266 /* By now UMV IS DISABLED ON H.263v1, since the restrictions |
267 of H.263v1 UMV implies to check the predicted MV after | |
268 calculation of the current MB to see if we're on the limits */ | |
2979 | 269 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ |
270 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
271 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ | |
272 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ | |
0 | 273 put_bits(&s->pb, 5, s->qscale); |
2979 | 274 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
0 | 275 } else { |
1872 | 276 int ufep=1; |
0 | 277 /* H.263v2 */ |
278 /* H.263 Plus PTYPE */ | |
2967 | 279 |
0 | 280 put_bits(&s->pb, 3, 7); |
1872 | 281 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */ |
78 | 282 if (format == 7) |
283 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
284 else | |
285 put_bits(&s->pb, 3, format); | |
2967 | 286 |
1872 | 287 put_bits(&s->pb,1, s->custom_pcf); |
1661 | 288 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 289 put_bits(&s->pb,1,0); /* SAC: off */ |
1633 | 290 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
291 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
1644 | 292 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ |
1661 | 293 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ |
0 | 294 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ |
295 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
1637 | 296 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ |
1644 | 297 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ |
0 | 298 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
299 put_bits(&s->pb,3,0); /* Reserved */ | |
2967 | 300 |
6481 | 301 put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE); |
2967 | 302 |
0 | 303 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ |
304 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
|
305 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 306 put_bits(&s->pb,2,0); /* Reserved */ |
307 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
2967 | 308 |
0 | 309 /* This should be here if PLUSPTYPE */ |
2979 | 310 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
311 | |
312 if (format == 7) { | |
78 | 313 /* Custom Picture Format (CPFMT) */ |
1548 | 314 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 315 |
316 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 317 put_bits(&s->pb,9,(s->width >> 2) - 1); |
318 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
319 put_bits(&s->pb,9,(s->height >> 2)); | |
1548 | 320 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
321 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
322 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
2979 | 323 } |
78 | 324 } |
1872 | 325 if(s->custom_pcf){ |
326 if(ufep){ | |
327 put_bits(&s->pb, 1, best_clock_code); | |
328 put_bits(&s->pb, 7, best_divisor); | |
329 } | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
330 put_sbits(&s->pb, 2, temp_ref>>8); |
1872 | 331 } |
2967 | 332 |
0 | 333 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
334 if (s->umvplus) |
1089 | 335 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
1644 | 336 //FIXME check actual requested range |
1089 | 337 put_bits(&s->pb,2,1); /* unlimited */ |
1661 | 338 if(s->h263_slice_structured) |
339 put_bits(&s->pb,2,0); /* no weird submodes */ | |
1089 | 340 |
0 | 341 put_bits(&s->pb, 5, s->qscale); |
342 } | |
343 | |
2979 | 344 put_bits(&s->pb, 1, 0); /* no PEI */ |
498 | 345 |
1670 | 346 if(s->h263_slice_structured){ |
347 put_bits(&s->pb, 1, 1); | |
2967 | 348 |
1670 | 349 assert(s->mb_x == 0 && s->mb_y == 0); |
350 ff_h263_encode_mba(s); | |
351 | |
352 put_bits(&s->pb, 1, 1); | |
353 } | |
354 | |
498 | 355 if(s->h263_aic){ |
2967 | 356 s->y_dc_scale_table= |
1639 | 357 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 358 }else{ |
359 s->y_dc_scale_table= | |
360 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
361 } | |
0 | 362 } |
363 | |
766 | 364 /** |
365 * Encodes a group of blocks header. | |
366 */ | |
1661 | 367 void h263_encode_gob_header(MpegEncContext * s, int mb_line) |
162 | 368 { |
1661 | 369 put_bits(&s->pb, 17, 1); /* GBSC */ |
370 | |
371 if(s->h263_slice_structured){ | |
372 put_bits(&s->pb, 1, 1); | |
373 | |
374 ff_h263_encode_mba(s); | |
375 | |
376 if(s->mb_num > 1583) | |
377 put_bits(&s->pb, 1, 1); | |
378 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
379 put_bits(&s->pb, 1, 1); | |
6481 | 380 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ |
1661 | 381 }else{ |
382 int gob_number= mb_line / s->gob_index; | |
383 | |
384 put_bits(&s->pb, 5, gob_number); /* GN */ | |
6481 | 385 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ |
1661 | 386 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
387 } | |
162 | 388 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
389 |
1492 | 390 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ |
391 int last=0; | |
392 int j; | |
393 int rate=0; | |
394 | |
395 for(j=1; j<=block_last_index; j++){ | |
396 const int index= scantable[j]; | |
397 int level= block[index]; | |
398 if(level){ | |
399 level+= 64; | |
400 if((level&(~127)) == 0){ | |
401 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; | |
402 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; | |
403 }else | |
404 rate += s->ac_esc_length; | |
405 level-= 64; | |
406 | |
407 last= j; | |
408 } | |
409 } | |
2967 | 410 |
1492 | 411 return rate; |
412 } | |
413 | |
414 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
415 { |
1492 | 416 int score= 0; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
417 int i, n; |
903 | 418 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
|
419 |
1492 | 420 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); |
2967 | 421 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
422 for(n=0; n<6; n++){ |
1064 | 423 int16_t *ac_val, *ac_val1; |
2967 | 424 |
1492 | 425 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
426 |
266 | 427 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
|
428 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
429 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
|
430 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
|
431 /* top prediction */ |
266 | 432 ac_val-= s->block_wrap[n]*16; |
903 | 433 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
|
434 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
435 for(i=1; i<8; i++){ |
1092 | 436 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 437 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; |
1092 | 438 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
|
439 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
440 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
441 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
442 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
443 for(i=1; i<8; i++){ |
1092 | 444 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 445 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
1092 | 446 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
|
447 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
448 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
449 } |
1492 | 450 st[n]= s->intra_h_scantable.permutated; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
451 }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
|
452 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
|
453 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
454 ac_val-= 16; |
903 | 455 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
|
456 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
457 for(i=1; i<8; i++){ |
1092 | 458 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 459 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
460 ac_val1[i ]= level; |
1092 | 461 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
|
462 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
463 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
464 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
465 for(i=1; i<8; i++){ |
1092 | 466 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 467 block[n][s->dsp.idct_permutation[i<<3]]= 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
|
468 ac_val1[i ]= level; |
1092 | 469 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
|
470 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
471 } |
1492 | 472 st[n]= s->intra_v_scantable.permutated; |
473 } | |
474 | |
475 for(i=63; i>0; i--) //FIXME optimize | |
476 if(block[n][ st[n][i] ]) break; | |
477 s->block_last_index[n]= i; | |
478 | |
479 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); | |
480 } | |
481 | |
482 return score < 0; | |
483 } | |
484 | |
485 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
486 { | |
487 int i, n; | |
488 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); | |
489 | |
490 for(n=0; n<6; n++){ | |
491 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
492 | |
493 st[n]= s->intra_scantable.permutated; | |
494 if(dir[n]){ | |
495 /* top prediction */ | |
496 for(i=1; i<8; i++){ | |
497 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8]; | |
498 } | |
499 }else{ | |
500 /* left prediction */ | |
501 for(i=1; i<8; i++){ | |
502 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ]; | |
503 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
504 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
505 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
506 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
507 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
508 /** |
4316 | 509 * init s->current_picture.qscale_table from s->lambda_table |
510 */ | |
511 static void ff_init_qscale_tab(MpegEncContext *s){ | |
512 int8_t * const qscale_table= s->current_picture.qscale_table; | |
513 int i; | |
514 | |
515 for(i=0; i<s->mb_num; i++){ | |
516 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ]; | |
517 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); | |
4594 | 518 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax); |
4316 | 519 } |
520 } | |
521 | |
522 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
523 * 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
|
524 */ |
695 | 525 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
526 int i; |
903 | 527 int8_t * const qscale_table= s->current_picture.qscale_table; |
2967 | 528 |
4316 | 529 ff_init_qscale_tab(s); |
530 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
531 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
|
532 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
|
533 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
|
534 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
535 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
|
536 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
|
537 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
|
538 } |
1983 | 539 |
540 if(s->codec_id != CODEC_ID_H263P){ | |
541 for(i=1; i<s->mb_num; i++){ | |
542 int mb_xy= s->mb_index2xy[i]; | |
2967 | 543 |
1983 | 544 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ |
545 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER; | |
546 } | |
547 } | |
548 } | |
695 | 549 } |
550 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
551 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
552 * 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
|
553 */ |
695 | 554 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
555 int i; | |
903 | 556 int8_t * const qscale_table= s->current_picture.qscale_table; |
557 | |
695 | 558 ff_clean_h263_qscales(s); |
2967 | 559 |
6481 | 560 if(s->pict_type== FF_B_TYPE){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
561 int odd=0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
562 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */ |
2967 | 563 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
564 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
|
565 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
|
566 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
567 } |
2967 | 568 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
569 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
570 else odd=0; |
2967 | 571 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
572 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
|
573 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
|
574 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
|
575 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
|
576 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
|
577 qscale_table[mb_xy]= 31; |
2967 | 578 } |
579 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
580 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
|
581 int mb_xy= s->mb_index2xy[i]; |
1708 | 582 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ |
583 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
584 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
585 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
586 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
587 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
588 |
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
|
589 #endif //CONFIG_ENCODERS |
3247 | 590 |
8042 | 591 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0])) |
3255
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
592 #define tab_bias (tab_size/2) |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
593 |
3791
b1d5ef809e11
fix rv20 b frames (broke since r5264 Mon Apr 3 07:52:24 2006 UTC 2x faster ff_mpeg4_set_direct_mv)
michael
parents:
3781
diff
changeset
|
594 void ff_mpeg4_init_direct_mv(MpegEncContext *s){ |
3247 | 595 int i; |
596 for(i=0; i<tab_size; i++){ | |
597 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time; | |
598 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time; | |
599 } | |
600 } | |
601 | |
602 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){ | |
603 int xy= s->block_index[i]; | |
604 uint16_t time_pp= s->pp_time; | |
605 uint16_t time_pb= s->pb_time; | |
606 int p_mx, p_my; | |
607 | |
608 p_mx= s->next_picture.motion_val[0][xy][0]; | |
609 if((unsigned)(p_mx + tab_bias) < tab_size){ | |
610 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; | |
611 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
612 : s->direct_scale_mv[1][p_mx + tab_bias]; | |
613 }else{ | |
614 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx; | |
615 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
616 : p_mx*(time_pb - time_pp)/time_pp; | |
617 } | |
618 p_my= s->next_picture.motion_val[0][xy][1]; | |
619 if((unsigned)(p_my + tab_bias) < tab_size){ | |
620 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; | |
621 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
622 : s->direct_scale_mv[1][p_my + tab_bias]; | |
623 }else{ | |
624 s->mv[0][i][1] = p_my*time_pb/time_pp + my; | |
625 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
626 : p_my*(time_pb - time_pp)/time_pp; | |
627 } | |
628 } | |
629 | |
3255
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
630 #undef tab_size |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
631 #undef tab_bias |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
632 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
633 /** |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
634 * |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
635 * @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
|
636 */ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
637 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
|
638 const int mb_index= s->mb_x + s->mb_y*s->mb_stride; |
1708 | 639 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; |
936 | 640 uint16_t time_pp= s->pp_time; |
641 uint16_t time_pb= s->pb_time; | |
642 int i; | |
2967 | 643 |
936 | 644 //FIXME avoid divides |
3247 | 645 // try special case with shifts for 1 and 3 B-frames? |
2967 | 646 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
647 if(IS_8X8(colocated_mb_type)){ |
936 | 648 s->mv_type = MV_TYPE_8X8; |
649 for(i=0; i<4; i++){ | |
3247 | 650 ff_mpeg4_set_one_direct_mv(s, mx, my, i); |
936 | 651 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
652 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
|
653 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 654 s->mv_type = MV_TYPE_FIELD; |
655 for(i=0; i<2; i++){ | |
1948 | 656 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]]; |
3205 | 657 s->field_select[0][i]= field_select; |
658 s->field_select[1][i]= i; | |
936 | 659 if(s->top_field_first){ |
1948 | 660 time_pp= s->pp_field_time - field_select + i; |
661 time_pb= s->pb_field_time - field_select + i; | |
936 | 662 }else{ |
1948 | 663 time_pp= s->pp_field_time + field_select - i; |
664 time_pb= s->pb_field_time + field_select - i; | |
936 | 665 } |
1708 | 666 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; |
667 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; | |
668 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0] | |
669 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp; | |
2967 | 670 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] |
1708 | 671 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp; |
936 | 672 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
673 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
|
674 }else{ |
3247 | 675 ff_mpeg4_set_one_direct_mv(s, mx, my, 0); |
676 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0]; | |
677 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1]; | |
678 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0]; | |
679 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][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
|
680 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
|
681 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
|
682 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
|
683 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
|
684 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 685 } |
686 } | |
687 | |
1389 | 688 void ff_h263_update_motion_val(MpegEncContext * s){ |
689 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
690 //FIXME a lot of that is only needed for !low_delay |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
691 const int wrap = s->b8_stride; |
1389 | 692 const int xy = s->block_index[0]; |
2967 | 693 |
694 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped; | |
1389 | 695 |
696 if(s->mv_type != MV_TYPE_8X8){ | |
697 int motion_x, motion_y; | |
698 if (s->mb_intra) { | |
699 motion_x = 0; | |
700 motion_y = 0; | |
701 } else if (s->mv_type == MV_TYPE_16X16) { | |
702 motion_x = s->mv[0][0][0]; | |
703 motion_y = s->mv[0][0][1]; | |
704 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { | |
705 int i; | |
706 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; | |
707 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; | |
708 motion_x = (motion_x>>1) | (motion_x&1); | |
709 for(i=0; i<2; i++){ | |
1708 | 710 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0]; |
711 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1]; | |
1389 | 712 } |
1948 | 713 s->current_picture.ref_index[0][xy ]= |
714 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0]; | |
715 s->current_picture.ref_index[0][xy + wrap ]= | |
716 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1]; | |
1389 | 717 } |
1948 | 718 |
1389 | 719 /* no update if 8X8 because it has been done during parsing */ |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
720 s->current_picture.motion_val[0][xy][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
721 s->current_picture.motion_val[0][xy][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
722 s->current_picture.motion_val[0][xy + 1][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
723 s->current_picture.motion_val[0][xy + 1][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
724 s->current_picture.motion_val[0][xy + wrap][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
725 s->current_picture.motion_val[0][xy + wrap][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
726 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
727 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; |
1389 | 728 } |
729 | |
730 if(s->encoding){ //FIXME encoding MUST be cleaned up | |
2967 | 731 if (s->mv_type == MV_TYPE_8X8) |
1389 | 732 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; |
1633 | 733 else if(s->mb_intra) |
734 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; | |
1389 | 735 else |
736 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | |
737 } | |
738 } | |
739 | |
8590 | 740 #if CONFIG_ENCODERS |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
741 |
2502 | 742 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){ |
743 int l, bit_size, code; | |
744 | |
745 if (val == 0) { | |
746 return mvtab[0][1]; | |
747 } else { | |
748 bit_size = f_code - 1; | |
749 /* modulo encoding */ | |
750 l= INT_BIT - 6 - bit_size; | |
751 val = (val<<l)>>l; | |
752 val--; | |
753 code = (val >> bit_size) + 1; | |
754 | |
755 return mvtab[code][1] + 1 + bit_size; | |
756 } | |
757 } | |
758 | |
759 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){ | |
760 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
2967 | 761 skip_put_bits(&s->pb, |
2502 | 762 h263_get_motion_length(s, x, f_code) |
763 +h263_get_motion_length(s, y, f_code)); | |
764 }else{ | |
765 ff_h263_encode_motion(s, x, f_code); | |
766 ff_h263_encode_motion(s, y, f_code); | |
767 } | |
768 } | |
769 | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
770 static inline int get_p_cbp(MpegEncContext * s, |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
771 DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
772 int motion_x, int motion_y){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
773 int cbp, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
774 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
775 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
776 int best_cbpy_score= INT_MAX; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
777 int best_cbpc_score= INT_MAX; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
778 int cbpc = (-1), cbpy= (-1); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
779 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0); |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1492
diff
changeset
|
780 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
781 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
782 for(i=0; i<4; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
783 int score= inter_MCBPC_bits[i + offset] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
784 if(i&1) score += s->coded_score[5]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
785 if(i&2) score += s->coded_score[4]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
786 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
787 if(score < best_cbpc_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
788 best_cbpc_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
789 cbpc= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
790 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
791 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
792 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
793 for(i=0; i<16; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
794 int score= cbpy_tab[i ^ 0xF][1] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
795 if(i&1) score += s->coded_score[3]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
796 if(i&2) score += s->coded_score[2]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
797 if(i&4) score += s->coded_score[1]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
798 if(i&8) score += s->coded_score[0]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
799 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
800 if(score < best_cbpy_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
801 best_cbpy_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
802 cbpy= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
803 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
804 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
805 cbp= cbpc + 4*cbpy; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
806 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
|
807 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
|
808 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
809 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
810 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
811 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
812 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
|
813 s->block_last_index[i]= -1; |
8288 | 814 s->dsp.clear_block(s->block[i]); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
815 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
816 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
817 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
818 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
819 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
820 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
821 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
822 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
823 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
824 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
825 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
826 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
827 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
|
828 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
|
829 int cbp=0, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
830 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
831 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
832 int score=0; |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1492
diff
changeset
|
833 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 834 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
835 for(i=0; i<6; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
836 if(s->coded_score[i] < 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
837 score += s->coded_score[i]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
838 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
839 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
840 } |
2967 | 841 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
842 if(cbp){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
843 int zero_score= -6; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
844 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
|
845 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
|
846 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
847 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
848 zero_score*= lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
849 if(zero_score <= score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
850 cbp=0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
851 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
852 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
853 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
854 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
855 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
|
856 s->block_last_index[i]= -1; |
8288 | 857 s->dsp.clear_block(s->block[i]); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
858 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
859 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
860 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
861 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
862 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
863 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
864 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
865 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
866 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
867 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
868 |
2967 | 869 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], |
2502 | 870 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){ |
871 int i; | |
2967 | 872 |
2502 | 873 if(scan_table){ |
874 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
875 for (i = 0; i < 6; i++) { | |
876 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i])); | |
877 } | |
878 }else{ | |
879 /* encode each block */ | |
880 for (i = 0; i < 6; i++) { | |
881 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb); | |
882 } | |
883 } | |
884 }else{ | |
885 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
886 for (i = 0; i < 6; i++) { | |
887 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated)); | |
888 } | |
889 }else{ | |
890 /* encode each block */ | |
891 for (i = 0; i < 6; i++) { | |
892 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb); | |
893 } | |
894 } | |
895 } | |
896 } | |
897 | |
8644 | 898 static const int dquant_code[5]= {1,0,9,2,3}; |
899 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
900 void mpeg4_encode_mb(MpegEncContext * s, |
2979 | 901 DCTELEM block[6][64], |
902 int motion_x, int motion_y) | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
903 { |
1057 | 904 int cbpc, cbpy, pred_x, pred_y; |
453 | 905 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
6481 | 906 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb; |
907 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2 : &s->pb; | |
453 | 908 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; |
2967 | 909 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
910 // 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
|
911 if (!s->mb_intra) { |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
912 int i, cbp; |
2967 | 913 |
6481 | 914 if(s->pict_type==FF_B_TYPE){ |
5445
5581a40c673a
exchange the values of MV_DIR_FORWARD and MV_DIR_BACKWARD (this is more sane,
michael
parents:
5405
diff
changeset
|
915 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ |
324 | 916 int mb_type= mb_type_table[s->mv_dir]; |
1708 | 917 |
324 | 918 if(s->mb_x==0){ |
1708 | 919 for(i=0; i<2; i++){ |
2967 | 920 s->last_mv[i][0][0]= |
921 s->last_mv[i][0][1]= | |
922 s->last_mv[i][1][0]= | |
1708 | 923 s->last_mv[i][1][1]= 0; |
924 } | |
324 | 925 } |
2967 | 926 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
927 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
928 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
929 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
930 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
931 /* nothing to do if this MB was skipped 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
|
932 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 933 s->skip_count++; |
2967 | 934 s->mv[0][0][0]= |
935 s->mv[0][0][1]= | |
936 s->mv[1][0][0]= | |
324 | 937 s->mv[1][0][1]= 0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
938 s->mv_dir= MV_DIR_FORWARD; //doesn't matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
939 s->qscale -= s->dquant; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
940 // s->mb_skipped=1; |
903 | 941 |
324 | 942 return; |
943 } | |
2967 | 944 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
945 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); |
2967 | 946 |
324 | 947 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
948 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
949 assert(s->dquant==0); |
2967 | 950 |
324 | 951 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 952 |
953 if(interleaved_stats){ | |
954 s->misc_bits++; | |
955 s->last_bits++; | |
956 } | |
324 | 957 s->skip_count++; |
958 return; | |
959 } | |
2967 | 960 |
2979 | 961 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
324 | 962 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
963 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) |
324 | 964 if(cbp) put_bits(&s->pb, 6, cbp); |
2967 | 965 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
966 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
967 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
968 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
969 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
970 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
971 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
972 s->qscale -= s->dquant; |
2967 | 973 |
697 | 974 if(!s->progressive_sequence){ |
975 if(cbp) | |
976 put_bits(&s->pb, 1, s->interlaced_dct); | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
977 if(mb_type) // not direct mode |
1708 | 978 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD); |
697 | 979 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
980 |
453 | 981 if(interleaved_stats){ |
1164 | 982 s->misc_bits+= get_bits_diff(s); |
453 | 983 } |
295 | 984 |
1708 | 985 if(mb_type == 0){ |
986 assert(s->mv_dir & MV_DIRECT); | |
2502 | 987 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1); |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
988 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
989 s->f_count++; |
1708 | 990 }else{ |
991 assert(mb_type > 0 && mb_type < 4); | |
992 if(s->mv_type != MV_TYPE_FIELD){ | |
993 if(s->mv_dir & MV_DIR_FORWARD){ | |
2502 | 994 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0], |
995 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
1708 | 996 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0]; |
997 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1]; | |
998 s->f_count++; | |
999 } | |
1000 if(s->mv_dir & MV_DIR_BACKWARD){ | |
2502 | 1001 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0], |
1002 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
1708 | 1003 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0]; |
1004 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1]; | |
1005 s->b_count++; | |
1006 } | |
1007 }else{ | |
1008 if(s->mv_dir & MV_DIR_FORWARD){ | |
1009 put_bits(&s->pb, 1, s->field_select[0][0]); | |
1010 put_bits(&s->pb, 1, s->field_select[0][1]); | |
1011 } | |
1012 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1013 put_bits(&s->pb, 1, s->field_select[1][0]); | |
1014 put_bits(&s->pb, 1, s->field_select[1][1]); | |
1015 } | |
1016 if(s->mv_dir & MV_DIR_FORWARD){ | |
1017 for(i=0; i<2; i++){ | |
2502 | 1018 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] , |
1019 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code); | |
1708 | 1020 s->last_mv[0][i][0]= s->mv[0][i][0]; |
1021 s->last_mv[0][i][1]= s->mv[0][i][1]*2; | |
1022 } | |
1023 s->f_count++; | |
1024 } | |
1025 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1026 for(i=0; i<2; i++){ | |
2502 | 1027 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] , |
1028 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code); | |
1708 | 1029 s->last_mv[1][i][0]= s->mv[1][i][0]; |
1030 s->last_mv[1][i][1]= s->mv[1][i][1]*2; | |
1031 } | |
1032 s->b_count++; | |
1033 } | |
1034 } | |
324 | 1035 } |
453 | 1036 |
1037 if(interleaved_stats){ | |
1164 | 1038 s->mv_bits+= get_bits_diff(s); |
453 | 1039 } |
295 | 1040 |
2502 | 1041 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb); |
453 | 1042 |
1043 if(interleaved_stats){ | |
1164 | 1044 s->p_tex_bits+= get_bits_diff(s); |
453 | 1045 } |
1708 | 1046 |
6481 | 1047 }else{ /* s->pict_type==FF_B_TYPE */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1048 cbp= get_p_cbp(s, block, motion_x, motion_y); |
2967 | 1049 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1050 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
2967 | 1051 /* check if the B frames can skip it too, as we must skip it if we skip here |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
1052 why didn't they just compress the skip-mb bits instead of reusing them ?! */ |
331 | 1053 if(s->max_b_frames>0){ |
1054 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1055 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1056 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1057 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1058 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1059 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1060 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
|
1061 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
|
1062 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1063 offset= x + y*s->linesize; |
903 | 1064 p_pic= s->new_picture.data[0] + offset; |
2967 | 1065 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1066 s->mb_skipped=1; |
331 | 1067 for(i=0; i<s->max_b_frames; i++){ |
339 | 1068 uint8_t *b_pic; |
1069 int diff; | |
903 | 1070 Picture *pic= s->reordered_input_picture[i+1]; |
1071 | |
6481 | 1072 if(pic==NULL || pic->pict_type!=FF_B_TYPE) break; |
903 | 1073 |
3068 | 1074 b_pic= pic->data[0] + offset; |
1075 if(pic->type != FF_BUFFER_TYPE_SHARED) | |
1076 b_pic+= INPLACE_OFFSET; | |
2979 | 1077 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16); |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1078 if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1079 s->mb_skipped=0; |
331 | 1080 break; |
1081 } | |
1082 } | |
1083 }else | |
2967 | 1084 s->mb_skipped=1; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1085 |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1086 if(s->mb_skipped==1){ |
331 | 1087 /* skip macroblock */ |
1088 put_bits(&s->pb, 1, 1); | |
453 | 1089 |
1090 if(interleaved_stats){ | |
1091 s->misc_bits++; | |
1092 s->last_bits++; | |
1093 } | |
331 | 1094 s->skip_count++; |
2967 | 1095 |
331 | 1096 return; |
1097 } | |
295 | 1098 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1099 |
2979 | 1100 put_bits(&s->pb, 1, 0); /* mb coded */ |
1633 | 1101 cbpc = cbp & 3; |
1102 cbpy = cbp >> 2; | |
1103 cbpy ^= 0xf; | |
324 | 1104 if(s->mv_type==MV_TYPE_16X16){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1105 if(s->dquant) cbpc+= 8; |
324 | 1106 put_bits(&s->pb, |
1107 inter_MCBPC_bits[cbpc], | |
1108 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1109 |
453 | 1110 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
|
1111 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1112 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 1113 |
1114 if(!s->progressive_sequence){ | |
1115 if(cbp) | |
1116 put_bits(pb2, 1, s->interlaced_dct); | |
1708 | 1117 put_bits(pb2, 1, 0); |
697 | 1118 } |
2967 | 1119 |
453 | 1120 if(interleaved_stats){ |
1164 | 1121 s->misc_bits+= get_bits_diff(s); |
453 | 1122 } |
324 | 1123 |
1124 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1125 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1126 |
2502 | 1127 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1128 motion_y - pred_y, s->f_code); | |
1708 | 1129 }else if(s->mv_type==MV_TYPE_FIELD){ |
1130 if(s->dquant) cbpc+= 8; | |
1131 put_bits(&s->pb, | |
1132 inter_MCBPC_bits[cbpc], | |
1133 inter_MCBPC_code[cbpc]); | |
1134 | |
1135 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1136 if(s->dquant) | |
1137 put_bits(pb2, 2, dquant_code[s->dquant+2]); | |
1138 | |
1139 assert(!s->progressive_sequence); | |
1140 if(cbp) | |
1141 put_bits(pb2, 1, s->interlaced_dct); | |
1142 put_bits(pb2, 1, 1); | |
2967 | 1143 |
1708 | 1144 if(interleaved_stats){ |
1145 s->misc_bits+= get_bits_diff(s); | |
1146 } | |
1147 | |
1148 /* motion vectors: 16x8 interlaced mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1149 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1708 | 1150 pred_y /=2; |
2967 | 1151 |
1708 | 1152 put_bits(&s->pb, 1, s->field_select[0][0]); |
1153 put_bits(&s->pb, 1, s->field_select[0][1]); | |
2967 | 1154 |
2502 | 1155 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x, |
1156 s->mv[0][0][1] - pred_y, s->f_code); | |
1157 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x, | |
1158 s->mv[0][1][1] - pred_y, s->f_code); | |
324 | 1159 }else{ |
1708 | 1160 assert(s->mv_type==MV_TYPE_8X8); |
324 | 1161 put_bits(&s->pb, |
1633 | 1162 inter_MCBPC_bits[cbpc+16], |
1163 inter_MCBPC_code[cbpc+16]); | |
453 | 1164 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
1165 | |
757 | 1166 if(!s->progressive_sequence){ |
1167 if(cbp) | |
1168 put_bits(pb2, 1, s->interlaced_dct); | |
1169 } | |
2967 | 1170 |
453 | 1171 if(interleaved_stats){ |
1164 | 1172 s->misc_bits+= get_bits_diff(s); |
453 | 1173 } |
324 | 1174 |
1175 for(i=0; i<4; i++){ | |
1176 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1177 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
324 | 1178 |
2502 | 1179 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, |
1180 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); | |
324 | 1181 } |
1182 } | |
453 | 1183 |
2967 | 1184 if(interleaved_stats){ |
1164 | 1185 s->mv_bits+= get_bits_diff(s); |
453 | 1186 } |
324 | 1187 |
2502 | 1188 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb); |
453 | 1189 |
1190 if(interleaved_stats){ | |
1164 | 1191 s->p_tex_bits+= get_bits_diff(s); |
453 | 1192 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
1193 s->f_count++; |
295 | 1194 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1195 } else { |
324 | 1196 int cbp; |
2967 | 1197 int dc_diff[6]; //dc values with the dc prediction subtracted |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1198 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1199 int zigzag_last_index[6]; |
2979 | 1200 uint8_t *scan_table[6]; |
1057 | 1201 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1202 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1203 for(i=0; i<6; i++){ |
2003 | 1204 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1205 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1206 |
1492 | 1207 if(s->flags & CODEC_FLAG_AC_PRED){ |
1208 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); | |
1209 if(!s->ac_pred) | |
1210 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1211 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1212 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1213 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
|
1214 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1215 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1216 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1217 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1218 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1219 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1220 cbp |= 1 << (5 - i); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1221 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1222 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1223 cbpc = cbp & 3; |
6481 | 1224 if (s->pict_type == FF_I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1225 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1226 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1227 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1228 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1229 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1230 if(s->dquant) cbpc+=8; |
2979 | 1231 put_bits(&s->pb, 1, 0); /* mb coded */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1232 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1233 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1234 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1235 } |
453 | 1236 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
|
1237 cbpy = cbp >> 2; |
453 | 1238 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
|
1239 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1240 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 1241 |
697 | 1242 if(!s->progressive_sequence){ |
1243 put_bits(dc_pb, 1, s->interlaced_dct); | |
1244 } | |
1245 | |
453 | 1246 if(interleaved_stats){ |
1164 | 1247 s->misc_bits+= get_bits_diff(s); |
453 | 1248 } |
286 | 1249 |
2502 | 1250 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1251 |
453 | 1252 if(interleaved_stats){ |
1164 | 1253 s->i_tex_bits+= get_bits_diff(s); |
453 | 1254 } |
286 | 1255 s->i_count++; |
1256 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1257 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
1492 | 1258 if(s->ac_pred) |
1259 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1260 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1261 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1262 |
0 | 1263 void h263_encode_mb(MpegEncContext * s, |
2979 | 1264 DCTELEM block[6][64], |
1265 int motion_x, int motion_y) | |
0 | 1266 { |
1267 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 1268 int16_t pred_dc; |
1269 int16_t rec_intradc[6]; | |
3781 | 1270 int16_t *dc_ptr[6]; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1271 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
2967 | 1272 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1273 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
324 | 1274 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1275 /* compute cbp */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1276 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
|
1277 |
1789 | 1278 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) { |
324 | 1279 /* skip macroblock */ |
1280 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
|
1281 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1282 s->misc_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1283 s->last_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1284 } |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
1285 s->skip_count++; |
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
1286 |
324 | 1287 return; |
1288 } | |
2979 | 1289 put_bits(&s->pb, 1, 0); /* mb coded */ |
2967 | 1290 |
324 | 1291 cbpc = cbp & 3; |
1637 | 1292 cbpy = cbp >> 2; |
1293 if(s->alt_inter_vlc==0 || cbpc!=3) | |
1294 cbpy ^= 0xF; | |
695 | 1295 if(s->dquant) cbpc+= 8; |
1633 | 1296 if(s->mv_type==MV_TYPE_16X16){ |
1297 put_bits(&s->pb, | |
1298 inter_MCBPC_bits[cbpc], | |
1299 inter_MCBPC_code[cbpc]); | |
1300 | |
1301 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1302 if(s->dquant) | |
1303 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
2967 | 1304 |
1633 | 1305 if(interleaved_stats){ |
1306 s->misc_bits+= get_bits_diff(s); | |
1307 } | |
1308 | |
1309 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1310 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1311 |
1312 if (!s->umvplus) { | |
2502 | 1313 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1314 motion_y - pred_y, 1); | |
1633 | 1315 } |
1316 else { | |
1317 h263p_encode_umotion(s, motion_x - pred_x); | |
1318 h263p_encode_umotion(s, motion_y - pred_y); | |
1319 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1320 /* To prevent Start Code emulation */ | |
1321 put_bits(&s->pb,1,1); | |
1322 } | |
1323 }else{ | |
1324 put_bits(&s->pb, | |
1325 inter_MCBPC_bits[cbpc+16], | |
1326 inter_MCBPC_code[cbpc+16]); | |
1327 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1328 if(s->dquant) | |
1329 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1330 | |
1331 if(interleaved_stats){ | |
1332 s->misc_bits+= get_bits_diff(s); | |
1333 } | |
1334 | |
1335 for(i=0; i<4; i++){ | |
1336 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1337 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 1338 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1339 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1340 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
2967 | 1341 if (!s->umvplus) { |
2502 | 1342 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1343 motion_y - pred_y, 1); | |
1633 | 1344 } |
1345 else { | |
1346 h263p_encode_umotion(s, motion_x - pred_x); | |
1347 h263p_encode_umotion(s, motion_y - pred_y); | |
1348 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1349 /* To prevent Start Code emulation */ | |
1350 put_bits(&s->pb,1,1); | |
1351 } | |
1352 } | |
324 | 1353 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1354 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1355 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1356 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
|
1357 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1358 } else { |
1639 | 1359 assert(s->mb_intra); |
2967 | 1360 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1361 cbp = 0; |
1666 | 1362 if (s->h263_aic) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1363 /* Predict DC */ |
1666 | 1364 for(i=0; i<6; i++) { |
1064 | 1365 int16_t level = block[i][0]; |
1666 | 1366 int scale; |
2967 | 1367 |
1666 | 1368 if(i<4) scale= s->y_dc_scale; |
1369 else scale= s->c_dc_scale; | |
1370 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1371 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
|
1372 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1373 /* Quant */ |
1666 | 1374 if (level >= 0) |
1375 level = (level + (scale>>1))/scale; | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1376 else |
1666 | 1377 level = (level - (scale>>1))/scale; |
2967 | 1378 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1379 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1380 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
|
1381 s->block_last_index[i] = -1; |
1666 | 1382 |
1383 if(!s->modified_quant){ | |
1384 if (level < -127) | |
1385 level = -127; | |
1386 else if (level > 127) | |
1387 level = 127; | |
1388 } | |
1389 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1390 block[i][0] = level; |
2967 | 1391 /* Reconstruction */ |
1666 | 1392 rec_intradc[i] = scale*level + pred_dc; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1393 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1394 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1395 //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
|
1396 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1397 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1398 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1399 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1400 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
|
1401 rec_intradc[i] = 2047; |
2967 | 1402 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1403 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1404 *dc_ptr[i] = rec_intradc[i]; |
1666 | 1405 if (s->block_last_index[i] >= 0) |
1406 cbp |= 1 << (5 - i); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1407 } |
1666 | 1408 }else{ |
1409 for(i=0; i<6; i++) { | |
1410 /* compute cbp */ | |
1411 if (s->block_last_index[i] >= 1) | |
1412 cbp |= 1 << (5 - i); | |
1413 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1414 } |
0 | 1415 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1416 cbpc = cbp & 3; |
6481 | 1417 if (s->pict_type == FF_I_TYPE) { |
695 | 1418 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
|
1419 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1420 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1421 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1422 } else { |
695 | 1423 if(s->dquant) cbpc+=8; |
2979 | 1424 put_bits(&s->pb, 1, 0); /* mb coded */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1425 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1426 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1427 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1428 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1429 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1430 /* XXX: currently, we do not try to use ac prediction */ |
2979 | 1431 put_bits(&s->pb, 1, 0); /* no AC prediction */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1432 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1433 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1434 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 1435 if(s->dquant) |
1436 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
|
1437 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1438 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1439 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
|
1440 } |
0 | 1441 } |
1442 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1443 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
|
1444 /* encode each block */ |
1354 | 1445 h263_encode_block(s, block[i], i); |
2967 | 1446 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1447 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1448 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
|
1449 block[i][0] = rec_intradc[i]; |
2967 | 1450 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1451 } |
0 | 1452 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1453 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1454 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1455 if (!s->mb_intra) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1456 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
|
1457 s->f_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1458 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1459 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
|
1460 s->i_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1461 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1462 } |
0 | 1463 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1464 #endif |
0 | 1465 |
1656 | 1466 void ff_h263_loop_filter(MpegEncContext * s){ |
1644 | 1467 int qp_c; |
1468 const int linesize = s->linesize; | |
1469 const int uvlinesize= s->uvlinesize; | |
1470 const int xy = s->mb_y * s->mb_stride + s->mb_x; | |
1471 uint8_t *dest_y = s->dest[0]; | |
1472 uint8_t *dest_cb= s->dest[1]; | |
1473 uint8_t *dest_cr= s->dest[2]; | |
2967 | 1474 |
6481 | 1475 // if(s->pict_type==FF_B_TYPE && !s->readable) return; |
1644 | 1476 |
1477 /* | |
1478 Diag Top | |
1479 Left Center | |
1480 */ | |
1481 if(!IS_SKIP(s->current_picture.mb_type[xy])){ | |
1482 qp_c= s->qscale; | |
1483 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c); | |
1484 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1485 }else | |
1486 qp_c= 0; | |
1487 | |
1488 if(s->mb_y){ | |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1489 int qp_dt, qp_tt, qp_tc; |
1644 | 1490 |
1491 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride])) | |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1492 qp_tt=0; |
2967 | 1493 else |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1494 qp_tt= s->current_picture.qscale_table[xy-s->mb_stride]; |
1644 | 1495 |
2967 | 1496 if(qp_c) |
1644 | 1497 qp_tc= qp_c; |
1498 else | |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1499 qp_tc= qp_tt; |
2967 | 1500 |
1644 | 1501 if(qp_tc){ |
1502 const int chroma_qp= s->chroma_qscale_table[qp_tc]; | |
1503 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); | |
1504 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc); | |
2967 | 1505 |
1644 | 1506 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); |
1507 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1508 } | |
2967 | 1509 |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1510 if(qp_tt) |
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1511 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_tt); |
2967 | 1512 |
1644 | 1513 if(s->mb_x){ |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1514 if(qp_tt || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride])) |
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1515 qp_dt= qp_tt; |
1644 | 1516 else |
1517 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride]; | |
2967 | 1518 |
1644 | 1519 if(qp_dt){ |
1520 const int chroma_qp= s->chroma_qscale_table[qp_dt]; | |
1521 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt); | |
1522 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp); | |
2178 | 1523 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp); |
1644 | 1524 } |
1525 } | |
1526 } | |
1527 | |
1528 if(qp_c){ | |
1529 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c); | |
1530 if(s->mb_y + 1 == s->mb_height) | |
1531 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1532 } | |
2967 | 1533 |
1644 | 1534 if(s->mb_x){ |
1535 int qp_lc; | |
1536 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1])) | |
1537 qp_lc= qp_c; | |
1538 else | |
1539 qp_lc= s->current_picture.qscale_table[xy-1]; | |
2967 | 1540 |
1644 | 1541 if(qp_lc){ |
1542 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); | |
1543 if(s->mb_y + 1 == s->mb_height){ | |
1544 const int chroma_qp= s->chroma_qscale_table[qp_lc]; | |
1545 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc); | |
1546 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); | |
1547 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1548 } | |
1549 } | |
1550 } | |
1551 } | |
1552 | |
8590 | 1553 #if CONFIG_ENCODERS |
3781 | 1554 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1555 { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1556 int x, y, wrap, a, c, pred_dc, scale; |
3781 | 1557 int16_t *dc_val; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1558 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1559 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1560 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1561 x = 2 * s->mb_x + (n & 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1562 y = 2 * s->mb_y + ((n & 2) >> 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1563 wrap = s->b8_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1564 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
|
1565 scale = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1566 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1567 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1568 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1569 wrap = s->mb_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1570 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
|
1571 scale = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1572 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1573 /* B C |
2967 | 1574 * A X |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1575 */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1576 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
|
1577 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1578 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1579 /* No prediction outside GOB boundary */ |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1580 if(s->first_slice_line && n!=3){ |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1581 if(n!=2) c= 1024; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1582 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1583 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1584 pred_dc = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1585 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1586 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1587 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1588 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1589 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1590 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1591 pred_dc = c; |
2967 | 1592 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1593 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1594 //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
|
1595 *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
|
1596 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1597 } |
3777 | 1598 #endif /* CONFIG_ENCODERS */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1599 |
1057 | 1600 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
|
1601 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1602 int x, y, wrap, a, c, pred_dc, scale, i; |
3781 | 1603 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1604 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1605 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1606 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1607 x = 2 * s->mb_x + (n & 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1608 y = 2 * s->mb_y + (n>> 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1609 wrap = s->b8_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1610 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1611 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1612 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1613 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1614 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1615 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1616 wrap = s->mb_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1617 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1618 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
|
1619 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1620 } |
2967 | 1621 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1622 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1623 ac_val1 = ac_val; |
2967 | 1624 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1625 /* B C |
2967 | 1626 * A X |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1627 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1628 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1629 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1630 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1631 /* No prediction outside GOB boundary */ |
1639 | 1632 if(s->first_slice_line && n!=3){ |
1633 if(n!=2) c= 1024; | |
1634 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; | |
1635 } | |
2967 | 1636 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1637 if (s->ac_pred) { |
1639 | 1638 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1639 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1640 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1641 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1642 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1643 for(i=1;i<8;i++) { |
1092 | 1644 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
|
1645 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1646 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1647 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1648 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1649 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1650 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1651 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1652 for(i=1;i<8;i++) { |
1092 | 1653 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
|
1654 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1655 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1656 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1657 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1658 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1659 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1660 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1661 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1662 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1663 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1664 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1665 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1666 } |
2967 | 1667 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1668 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1669 block[0]=block[0]*scale + pred_dc; |
2967 | 1670 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1671 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1672 block[0] = 0; |
2967 | 1673 else |
1639 | 1674 block[0] |= 1; |
2967 | 1675 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1676 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1677 dc_val[(x) + (y) * wrap] = block[0]; |
2967 | 1678 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1679 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1680 for(i=1;i<8;i++) |
1092 | 1681 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
|
1682 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1683 for(i=1;i<8;i++) |
1092 | 1684 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
|
1685 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1686 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1687 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir, |
0 | 1688 int *px, int *py) |
1689 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1690 int wrap; |
1655 | 1691 int16_t *A, *B, *C, (*mot_val)[2]; |
1692 static const int off[4]= {2, 1, 1, -1}; | |
1693 | |
1694 wrap = s->b8_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1695 mot_val = s->current_picture.motion_val[dir] + s->block_index[block]; |
1655 | 1696 |
1697 A = mot_val[ - 1]; | |
1698 /* special case for first (slice) line */ | |
1699 if (s->first_slice_line && block<3) { | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
1700 // we can't just change some MVs to simulate that as we need them for the B frames (and ME) |
1655 | 1701 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( |
1702 if(block==0){ //most common case | |
1703 if(s->mb_x == s->resync_mb_x){ //rare | |
1704 *px= *py = 0; | |
1705 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1706 C = mot_val[off[block] - wrap]; | |
1707 if(s->mb_x==0){ | |
1708 *px = C[0]; | |
1709 *py = C[1]; | |
1710 }else{ | |
1711 *px = mid_pred(A[0], 0, C[0]); | |
1712 *py = mid_pred(A[1], 0, C[1]); | |
1713 } | |
1714 }else{ | |
1715 *px = A[0]; | |
1716 *py = A[1]; | |
1717 } | |
1718 }else if(block==1){ | |
1719 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1720 C = mot_val[off[block] - wrap]; | |
1721 *px = mid_pred(A[0], 0, C[0]); | |
1722 *py = mid_pred(A[1], 0, C[1]); | |
1723 }else{ | |
1724 *px = A[0]; | |
1725 *py = A[1]; | |
1726 } | |
1727 }else{ /* block==2*/ | |
1728 B = mot_val[ - wrap]; | |
1729 C = mot_val[off[block] - wrap]; | |
1730 if(s->mb_x == s->resync_mb_x) //rare | |
1731 A[0]=A[1]=0; | |
2967 | 1732 |
1655 | 1733 *px = mid_pred(A[0], B[0], C[0]); |
1734 *py = mid_pred(A[1], B[1], C[1]); | |
1735 } | |
1736 } else { | |
1737 B = mot_val[ - wrap]; | |
1738 C = mot_val[off[block] - wrap]; | |
1739 *px = mid_pred(A[0], B[0], C[0]); | |
1740 *py = mid_pred(A[1], B[1], C[1]); | |
1741 } | |
1742 return *mot_val; | |
1743 } | |
1744 | |
8590 | 1745 #if CONFIG_ENCODERS |
2017 | 1746 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1747 { |
702 | 1748 int range, l, bit_size, sign, code, bits; |
0 | 1749 |
1750 if (val == 0) { | |
1751 /* zero vector */ | |
1752 code = 0; | |
1753 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1754 } else { | |
324 | 1755 bit_size = f_code - 1; |
0 | 1756 range = 1 << bit_size; |
1757 /* modulo encoding */ | |
2093 | 1758 l= INT_BIT - 6 - bit_size; |
1759 val = (val<<l)>>l; | |
702 | 1760 sign = val>>31; |
1761 val= (val^sign)-sign; | |
1762 sign&=1; | |
2093 | 1763 |
312 | 1764 val--; |
1765 code = (val >> bit_size) + 1; | |
1766 bits = val & (range - 1); | |
0 | 1767 |
2967 | 1768 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); |
0 | 1769 if (bit_size > 0) { |
1770 put_bits(&s->pb, bit_size, bits); | |
1771 } | |
1772 } | |
1773 } | |
1774 | |
78 | 1775 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1776 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1777 { | |
2967 | 1778 short sval = 0; |
78 | 1779 short i = 0; |
1780 short n_bits = 0; | |
1781 short temp_val; | |
1782 int code = 0; | |
1783 int tcode; | |
2967 | 1784 |
78 | 1785 if ( val == 0) |
1786 put_bits(&s->pb, 1, 1); | |
1787 else if (val == 1) | |
1788 put_bits(&s->pb, 3, 0); | |
1789 else if (val == -1) | |
1790 put_bits(&s->pb, 3, 2); | |
1791 else { | |
2967 | 1792 |
78 | 1793 sval = ((val < 0) ? (short)(-val):(short)val); |
1794 temp_val = sval; | |
2967 | 1795 |
78 | 1796 while (temp_val != 0) { |
1797 temp_val = temp_val >> 1; | |
1798 n_bits++; | |
1799 } | |
2967 | 1800 |
78 | 1801 i = n_bits - 1; |
1802 while (i > 0) { | |
1803 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1804 tcode = (tcode << 1) | 1; | |
1805 code = (code << 2) | tcode; | |
1806 i--; | |
1807 } | |
1808 code = ((code << 1) | (val < 0)) << 1; | |
1809 put_bits(&s->pb, (2*n_bits)+1, code); | |
1810 //printf("\nVal = %d\tCode = %d", sval, code); | |
1811 } | |
1812 } | |
1813 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1814 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
|
1815 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1816 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1817 int mv; |
2967 | 1818 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1819 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
|
1820 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
|
1821 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1822 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1823 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1824 else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1825 int val, bit_size, range, code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1826 |
1893
779bdf5063ce
1000000l (using uninitalized variable for initalizing bits per MV table)
michael
parents:
1873
diff
changeset
|
1827 bit_size = f_code - 1; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1828 range = 1 << bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1829 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1830 val=mv; |
2967 | 1831 if (val < 0) |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1832 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1833 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1834 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1835 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1836 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1837 }else{ |
2985 | 1838 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1839 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1840 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1841 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1842 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
|
1843 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1844 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1845 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1846 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
|
1847 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
|
1848 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1849 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1850 } |
287 | 1851 |
1852 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1853 umv_fcode_tab[mv]= 1; | |
1854 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1855 } |
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
|
1856 |
468 | 1857 static void init_uni_dc_tab(void) |
293 | 1858 { |
1859 int level, uni_code, uni_len; | |
1860 | |
312 | 1861 for(level=-256; level<256; level++){ |
293 | 1862 int size, v, l; |
1863 /* find number of bits */ | |
1864 size = 0; | |
1865 v = abs(level); | |
1866 while (v) { | |
1867 v >>= 1; | |
2979 | 1868 size++; |
293 | 1869 } |
1870 | |
1871 if (level < 0) | |
1872 l= (-level) ^ ((1 << size) - 1); | |
1873 else | |
1874 l= level; | |
1875 | |
1876 /* luminance */ | |
1877 uni_code= DCtab_lum[size][0]; | |
1878 uni_len = DCtab_lum[size][1]; | |
1879 | |
1880 if (size > 0) { | |
1881 uni_code<<=size; uni_code|=l; | |
1882 uni_len+=size; | |
1883 if (size > 8){ | |
1884 uni_code<<=1; uni_code|=1; | |
1885 uni_len++; | |
1886 } | |
1887 } | |
1013 | 1888 uni_DCtab_lum_bits[level+256]= uni_code; |
1889 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1890 |
1891 /* chrominance */ | |
1892 uni_code= DCtab_chrom[size][0]; | |
1893 uni_len = DCtab_chrom[size][1]; | |
2967 | 1894 |
293 | 1895 if (size > 0) { |
1896 uni_code<<=size; uni_code|=l; | |
1897 uni_len+=size; | |
1898 if (size > 8){ | |
1899 uni_code<<=1; uni_code|=1; | |
1900 uni_len++; | |
1901 } | |
1902 } | |
1013 | 1903 uni_DCtab_chrom_bits[level+256]= uni_code; |
1904 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1905 |
1906 } | |
1907 } | |
1908 | |
1064 | 1909 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
|
1910 int slevel, run, last; |
2967 | 1911 |
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
|
1912 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
|
1913 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
|
1914 |
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
|
1915 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
|
1916 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
|
1917 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
|
1918 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
|
1919 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
|
1920 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
|
1921 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
|
1922 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
|
1923 int level1, run1; |
2967 | 1924 |
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
|
1925 len_tab[index]= 100; |
2967 | 1926 |
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
|
1927 /* 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
|
1928 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
|
1929 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
|
1930 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
|
1931 bits=bits*2+sign; len++; |
2967 | 1932 |
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
|
1933 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
|
1934 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
|
1935 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
|
1936 } |
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
|
1937 #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
|
1938 /* 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
|
1939 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
|
1940 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
|
1941 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
|
1942 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
|
1943 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
|
1944 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
|
1945 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
|
1946 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
|
1947 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
|
1948 bits=bits*2+sign; len++; |
2967 | 1949 |
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
|
1950 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
|
1951 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
|
1952 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
|
1953 } |
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
|
1954 } |
2967 | 1955 #endif |
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
|
1956 #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
|
1957 /* 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
|
1958 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
|
1959 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
|
1960 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
|
1961 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
|
1962 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
|
1963 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
|
1964 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
|
1965 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
|
1966 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
|
1967 bits=bits*2+sign; len++; |
2967 | 1968 |
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
|
1969 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
|
1970 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
|
1971 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
|
1972 } |
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
|
1973 } |
2967 | 1974 #endif |
1975 /* ESC3 */ | |
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
|
1976 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
|
1977 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
|
1978 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
|
1979 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
|
1980 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
|
1981 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
|
1982 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
|
1983 bits=bits*2+1; len++; //marker |
2967 | 1984 |
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
|
1985 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
|
1986 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
|
1987 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
|
1988 } |
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
|
1989 } |
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
|
1990 } |
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
|
1991 } |
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
|
1992 } |
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
|
1993 |
2253 | 1994 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
1995 int slevel, run, last; | |
2967 | 1996 |
2253 | 1997 assert(MAX_LEVEL >= 64); |
1998 assert(MAX_RUN >= 63); | |
1999 | |
2000 for(slevel=-64; slevel<64; slevel++){ | |
2001 if(slevel==0) continue; | |
2002 for(run=0; run<64; run++){ | |
2003 for(last=0; last<=1; last++){ | |
2004 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); | |
2005 int level= slevel < 0 ? -slevel : slevel; | |
2006 int sign= slevel < 0 ? 1 : 0; | |
2007 int bits, len, code; | |
2967 | 2008 |
2253 | 2009 len_tab[index]= 100; |
2967 | 2010 |
2253 | 2011 /* ESC0 */ |
2012 code= get_rl_index(rl, last, run, level); | |
2013 bits= rl->table_vlc[code][0]; | |
2014 len= rl->table_vlc[code][1]; | |
2015 bits=bits*2+sign; len++; | |
2967 | 2016 |
2253 | 2017 if(code!=rl->n && len < len_tab[index]){ |
2018 if(bits_tab) bits_tab[index]= bits; | |
2019 len_tab [index]= len; | |
2020 } | |
2021 /* ESC */ | |
2022 bits= rl->table_vlc[rl->n][0]; | |
2023 len = rl->table_vlc[rl->n][1]; | |
2024 bits=bits*2+last; len++; | |
2025 bits=bits*64+run; len+=6; | |
2026 bits=bits*256+(level&0xff); len+=8; | |
2967 | 2027 |
2253 | 2028 if(len < len_tab[index]){ |
2029 if(bits_tab) bits_tab[index]= bits; | |
2030 len_tab [index]= len; | |
2031 } | |
2032 } | |
2033 } | |
2034 } | |
2035 } | |
2036 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2037 void h263_encode_init(MpegEncContext *s) |
0 | 2038 { |
2039 static int done = 0; | |
2040 | |
2041 if (!done) { | |
2042 done = 1; | |
293 | 2043 |
2044 init_uni_dc_tab(); | |
2045 | |
4668 | 2046 init_rl(&rl_inter, static_rl_table_store[0]); |
2047 init_rl(&rl_intra, static_rl_table_store[1]); | |
2048 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
2967 | 2049 |
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
|
2050 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
|
2051 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
|
2052 |
2253 | 2053 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); |
2054 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len); | |
2055 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2056 init_mv_penalty_and_fcode(s); |
0 | 2057 } |
936 | 2058 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p |
2967 | 2059 |
2253 | 2060 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len; |
2061 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; | |
2062 if(s->h263_aic){ | |
2063 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len; | |
2064 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; | |
2065 } | |
2066 s->ac_esc_length= 7+1+6+8; | |
2067 | |
287 | 2068 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 2069 switch(s->codec_id){ |
2070 case CODEC_ID_MPEG4: | |
2071 s->fcode_tab= fcode_tab; | |
2072 s->min_qcoeff= -2048; | |
2073 s->max_qcoeff= 2047; | |
945 | 2074 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
2075 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
2076 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
2077 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 2078 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
2079 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 2080 s->ac_esc_length= 7+2+1+6+1+12+1; |
1799 | 2081 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; |
2082 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
2083 | |
1424 | 2084 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ |
1483 | 2085 |
1424 | 2086 s->avctx->extradata= av_malloc(1024); |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1521
diff
changeset
|
2087 init_put_bits(&s->pb, s->avctx->extradata, 1024); |
2967 | 2088 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2089 if(!(s->workaround_bugs & FF_BUG_MS)) |
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2090 mpeg4_encode_visual_object_header(s); |
1424 | 2091 mpeg4_encode_vol_header(s, 0, 0); |
2092 | |
2093 // ff_mpeg4_stuffing(&s->pb); ? | |
2094 flush_put_bits(&s->pb); | |
1786 | 2095 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3; |
1424 | 2096 } |
2967 | 2097 |
344 | 2098 break; |
2099 case CODEC_ID_H263P: | |
1666 | 2100 if(s->umvplus) |
2101 s->fcode_tab= umv_fcode_tab; | |
2102 if(s->modified_quant){ | |
2103 s->min_qcoeff= -2047; | |
2104 s->max_qcoeff= 2047; | |
2105 }else{ | |
2106 s->min_qcoeff= -127; | |
2107 s->max_qcoeff= 127; | |
2108 } | |
344 | 2109 break; |
2967 | 2110 //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
|
2111 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2112 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2113 s->min_qcoeff= -1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2114 s->max_qcoeff= 1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2115 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2116 s->min_qcoeff= -127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2117 s->max_qcoeff= 127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2118 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2119 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2120 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
|
2121 break; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2122 default: //nothing needed - default table already set in mpegvideo.c |
1089 | 2123 s->min_qcoeff= -127; |
344 | 2124 s->max_qcoeff= 127; |
498 | 2125 s->y_dc_scale_table= |
2126 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 2127 } |
0 | 2128 } |
2129 | |
1034 | 2130 /** |
2131 * encodes a 8x8 block. | |
2132 * @param block the 8x8 block | |
2133 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2134 */ | |
0 | 2135 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
2136 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2137 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
|
2138 RLTable *rl; |
0 | 2139 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2140 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2141 if (s->mb_intra && !s->h263_aic) { |
231 | 2142 /* DC coef */ |
1089 | 2143 level = block[0]; |
0 | 2144 /* 255 cannot be represented, so we clamp */ |
2145 if (level > 254) { | |
2146 level = 254; | |
2147 block[0] = 254; | |
2148 } | |
231 | 2149 /* 0 cannot be represented also */ |
1089 | 2150 else if (level < 1) { |
231 | 2151 level = 1; |
2152 block[0] = 1; | |
2153 } | |
1090 | 2154 if (level == 128) //FIXME check rv10 |
1089 | 2155 put_bits(&s->pb, 8, 0xff); |
2156 else | |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
2157 put_bits(&s->pb, 8, level); |
1089 | 2158 i = 1; |
0 | 2159 } else { |
1089 | 2160 i = 0; |
2161 if (s->h263_aic && s->mb_intra) | |
2162 rl = &rl_intra_aic; | |
2967 | 2163 |
1637 | 2164 if(s->alt_inter_vlc && !s->mb_intra){ |
2165 int aic_vlc_bits=0; | |
2166 int inter_vlc_bits=0; | |
2167 int wrong_pos=-1; | |
2168 int aic_code; | |
2967 | 2169 |
1637 | 2170 last_index = s->block_last_index[n]; |
2171 last_non_zero = i - 1; | |
2172 for (; i <= last_index; i++) { | |
2173 j = s->intra_scantable.permutated[i]; | |
2174 level = block[j]; | |
2175 if (level) { | |
2176 run = i - last_non_zero - 1; | |
2177 last = (i == last_index); | |
2967 | 2178 |
1663 | 2179 if(level<0) level= -level; |
2967 | 2180 |
1637 | 2181 code = get_rl_index(rl, last, run, level); |
2182 aic_code = get_rl_index(&rl_intra_aic, last, run, level); | |
2183 inter_vlc_bits += rl->table_vlc[code][1]+1; | |
2184 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; | |
2185 | |
2186 if (code == rl->n) { | |
1663 | 2187 inter_vlc_bits += 1+6+8-1; |
2967 | 2188 } |
1637 | 2189 if (aic_code == rl_intra_aic.n) { |
1663 | 2190 aic_vlc_bits += 1+6+8-1; |
1637 | 2191 wrong_pos += run + 1; |
2192 }else | |
2193 wrong_pos += wrong_run[aic_code]; | |
2194 last_non_zero = i; | |
2967 | 2195 } |
1637 | 2196 } |
2197 i = 0; | |
2198 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) | |
2199 rl = &rl_intra_aic; | |
2200 } | |
0 | 2201 } |
2967 | 2202 |
0 | 2203 /* AC coefs */ |
2204 last_index = s->block_last_index[n]; | |
2205 last_non_zero = i - 1; | |
2206 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
2207 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
|
2208 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2209 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2210 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
|
2211 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2212 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2213 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2214 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2215 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2216 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2217 } |
0 | 2218 code = get_rl_index(rl, last, run, level); |
2219 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2220 if (code == rl->n) { | |
1354 | 2221 if(s->h263_flv <= 1){ |
0 | 2222 put_bits(&s->pb, 1, last); |
2223 put_bits(&s->pb, 6, run); | |
2967 | 2224 |
1089 | 2225 assert(slevel != 0); |
2226 | |
2967 | 2227 if(level < 128) |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2228 put_sbits(&s->pb, 8, slevel); |
1089 | 2229 else{ |
2230 put_bits(&s->pb, 8, 128); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2231 put_sbits(&s->pb, 5, slevel); |
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2232 put_sbits(&s->pb, 6, slevel>>5); |
1089 | 2233 } |
1354 | 2234 }else{ |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
2235 if(level < 64) { // 7-bit level |
1354 | 2236 put_bits(&s->pb, 1, 0); |
2237 put_bits(&s->pb, 1, last); | |
2238 put_bits(&s->pb, 6, run); | |
2239 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2240 put_sbits(&s->pb, 7, slevel); |
1354 | 2241 } else { |
2242 /* 11-bit level */ | |
2243 put_bits(&s->pb, 1, 1); | |
2244 put_bits(&s->pb, 1, last); | |
2245 put_bits(&s->pb, 6, run); | |
2246 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2247 put_sbits(&s->pb, 11, slevel); |
1354 | 2248 } |
2249 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2250 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2251 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
|
2252 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2253 last_non_zero = i; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2254 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2255 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2256 } |
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
|
2257 |
0 | 2258 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2259 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2260 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2261 */ |
453 | 2262 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 2263 { |
2264 int length; | |
2265 put_bits(pbc, 1, 0); | |
1786 | 2266 length= (-put_bits_count(pbc))&7; |
453 | 2267 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 2268 } |
2269 | |
327 | 2270 /* must be called before writing the header */ |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5268
diff
changeset
|
2271 void ff_set_mpeg4_time(MpegEncContext * s){ |
6481 | 2272 if(s->pict_type==FF_B_TYPE){ |
3247 | 2273 ff_mpeg4_init_direct_mv(s); |
327 | 2274 }else{ |
2275 s->last_time_base= s->time_base; | |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5268
diff
changeset
|
2276 s->time_base= s->time/s->avctx->time_base.den; |
327 | 2277 } |
2278 } | |
2279 | |
942 | 2280 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
2281 int hours, minutes, seconds; | |
1763
951403db901f
first coded vs. first displayed pts (segfault & pts fix if b frames are used)
michael
parents:
1760
diff
changeset
|
2282 int64_t time; |
2967 | 2283 |
942 | 2284 put_bits(&s->pb, 16, 0); |
2285 put_bits(&s->pb, 16, GOP_STARTCODE); | |
2967 | 2286 |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2287 time= s->current_picture_ptr->pts; |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2288 if(s->reordered_input_picture[1]) |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2289 time= FFMIN(time, s->reordered_input_picture[1]->pts); |
2637 | 2290 time= time*s->avctx->time_base.num; |
2291 | |
2292 seconds= time/s->avctx->time_base.den; | |
942 | 2293 minutes= seconds/60; seconds %= 60; |
2294 hours= minutes/60; minutes %= 60; | |
2295 hours%=24; | |
2296 | |
2297 put_bits(&s->pb, 5, hours); | |
2298 put_bits(&s->pb, 6, minutes); | |
2299 put_bits(&s->pb, 1, 1); | |
2300 put_bits(&s->pb, 6, seconds); | |
2967 | 2301 |
2302 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); | |
942 | 2303 put_bits(&s->pb, 1, 0); //broken link == NO |
2967 | 2304 |
2305 s->last_time_base= time / s->avctx->time_base.den; | |
942 | 2306 |
2307 ff_mpeg4_stuffing(&s->pb); | |
2308 } | |
2309 | |
2310 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
2311 int profile_and_level_indication; | |
2312 int vo_ver_id; | |
2967 | 2313 |
2167 | 2314 if(s->avctx->profile != FF_PROFILE_UNKNOWN){ |
2315 profile_and_level_indication = s->avctx->profile << 4; | |
2316 }else if(s->max_b_frames || s->quarter_sample){ | |
2317 profile_and_level_indication= 0xF0; // adv simple | |
2318 }else{ | |
2319 profile_and_level_indication= 0x00; // simple | |
2320 } | |
2321 | |
2322 if(s->avctx->level != FF_LEVEL_UNKNOWN){ | |
2323 profile_and_level_indication |= s->avctx->level; | |
2324 }else{ | |
2325 profile_and_level_indication |= 1; //level 1 | |
2326 } | |
2327 | |
2328 if(profile_and_level_indication>>4 == 0xF){ | |
942 | 2329 vo_ver_id= 5; |
2330 }else{ | |
2331 vo_ver_id= 1; | |
2332 } | |
2167 | 2333 |
942 | 2334 //FIXME levels |
2335 | |
2336 put_bits(&s->pb, 16, 0); | |
2337 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2338 |
942 | 2339 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2340 |
942 | 2341 put_bits(&s->pb, 16, 0); |
2342 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
2967 | 2343 |
942 | 2344 put_bits(&s->pb, 1, 1); |
2345 put_bits(&s->pb, 4, vo_ver_id); | |
2346 put_bits(&s->pb, 3, 1); //priority | |
2967 | 2347 |
942 | 2348 put_bits(&s->pb, 4, 1); //visual obj type== video obj |
2967 | 2349 |
942 | 2350 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME |
2351 | |
2352 ff_mpeg4_stuffing(&s->pb); | |
2353 } | |
2354 | |
2355 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 2356 { |
942 | 2357 int vo_ver_id; |
336 | 2358 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
2359 if (!CONFIG_MPEG4_ENCODER) return; |
5275
91416b4f1929
Better place to disable some mpeg4 code and ensure that
aurel
parents:
5274
diff
changeset
|
2360 |
942 | 2361 if(s->max_b_frames || s->quarter_sample){ |
2362 vo_ver_id= 5; | |
923 | 2363 s->vo_type= ADV_SIMPLE_VO_TYPE; |
2364 }else{ | |
942 | 2365 vo_ver_id= 1; |
923 | 2366 s->vo_type= SIMPLE_VO_TYPE; |
2367 } | |
336 | 2368 |
263 | 2369 put_bits(&s->pb, 16, 0); |
942 | 2370 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 2371 put_bits(&s->pb, 16, 0); |
942 | 2372 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 2373 |
2979 | 2374 put_bits(&s->pb, 1, 0); /* random access vol */ |
2375 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2376 if(s->workaround_bugs & FF_BUG_MS) { |
2979 | 2377 put_bits(&s->pb, 1, 0); /* is obj layer id= no */ |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2378 } else { |
2979 | 2379 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
2380 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
2381 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2382 } |
2967 | 2383 |
1548 | 2384 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 2385 |
2386 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
1548 | 2387 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
2388 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
2389 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
2390 } |
336 | 2391 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2392 if(s->workaround_bugs & FF_BUG_MS) { // |
2979 | 2393 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */ |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2394 } else { |
2979 | 2395 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ |
2396 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2397 put_bits(&s->pb, 1, s->low_delay); |
2979 | 2398 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ |
2399 } | |
2400 | |
2401 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ | |
2402 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2967 | 2403 |
2637 | 2404 put_bits(&s->pb, 16, s->avctx->time_base.den); |
263 | 2405 if (s->time_increment_bits < 1) |
2406 s->time_increment_bits = 1; | |
2979 | 2407 put_bits(&s->pb, 1, 1); /* marker bit */ |
2408 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
2409 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2410 put_bits(&s->pb, 13, s->width); /* vol width */ | |
2411 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2412 put_bits(&s->pb, 13, s->height); /* vol height */ | |
2413 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 2414 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
2979 | 2415 put_bits(&s->pb, 1, 1); /* obmc disable */ |
263 | 2416 if (vo_ver_id == 1) { |
2979 | 2417 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ |
942 | 2418 }else{ |
2979 | 2419 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ |
2420 } | |
2421 | |
2422 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ | |
2423 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ | |
1411 | 2424 |
2425 if(s->mpeg_quant){ | |
2426 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
2427 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
2428 } | |
599 | 2429 |
263 | 2430 if (vo_ver_id != 1) |
936 | 2431 put_bits(&s->pb, 1, s->quarter_sample); |
2979 | 2432 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 2433 s->resync_marker= s->rtp_mode; |
2434 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
2435 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
2436 if(s->data_partitioning){ | |
2979 | 2437 put_bits(&s->pb, 1, 0); /* no rvlc */ |
453 | 2438 } |
2439 | |
263 | 2440 if (vo_ver_id != 1){ |
2979 | 2441 put_bits(&s->pb, 1, 0); /* newpred */ |
2442 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
2443 } | |
2444 put_bits(&s->pb, 1, 0); /* scalability */ | |
2967 | 2445 |
453 | 2446 ff_mpeg4_stuffing(&s->pb); |
676 | 2447 |
2448 /* user data */ | |
1092 | 2449 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 2450 put_bits(&s->pb, 16, 0); |
2979 | 2451 put_bits(&s->pb, 16, 0x1B2); /* user_data */ |
2452 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); | |
676 | 2453 } |
263 | 2454 } |
2455 | |
2456 /* write mpeg4 VOP header */ | |
2457 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
2458 { | |
324 | 2459 int time_incr; |
2460 int time_div, time_mod; | |
2967 | 2461 |
6481 | 2462 if(s->pict_type==FF_I_TYPE){ |
953 | 2463 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ |
2658
d1609cfeb1d0
#defines for strict_std_compliance and split between inofficial extensions and non standarized things
michael
parents:
2646
diff
changeset
|
2464 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2465 mpeg4_encode_visual_object_header(s); |
2658
d1609cfeb1d0
#defines for strict_std_compliance and split between inofficial extensions and non standarized things
michael
parents:
2646
diff
changeset
|
2466 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2467 mpeg4_encode_vol_header(s, 0, 0); |
942 | 2468 } |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2469 if(!(s->workaround_bugs & FF_BUG_MS)) |
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2470 mpeg4_encode_gop_header(s); |
453 | 2471 } |
2967 | 2472 |
6481 | 2473 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2474 |
2637 | 2475 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE); |
2967 | 2476 |
2979 | 2477 put_bits(&s->pb, 16, 0); /* vop header */ |
2478 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ | |
2479 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | |
324 | 2480 |
2679 | 2481 assert(s->time>=0); |
2637 | 2482 time_div= s->time/s->avctx->time_base.den; |
2483 time_mod= s->time%s->avctx->time_base.den; | |
324 | 2484 time_incr= time_div - s->last_time_base; |
1936
e5b0b33cf8aa
assert(time_incr >= 0) so its clear that this MUST be the case
michael
parents:
1914
diff
changeset
|
2485 assert(time_incr >= 0); |
324 | 2486 while(time_incr--) |
2487 put_bits(&s->pb, 1, 1); | |
2967 | 2488 |
0 | 2489 put_bits(&s->pb, 1, 0); |
2490 | |
2979 | 2491 put_bits(&s->pb, 1, 1); /* marker */ |
2492 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ | |
2493 put_bits(&s->pb, 1, 1); /* marker */ | |
2494 put_bits(&s->pb, 1, 1); /* vop coded */ | |
6481 | 2495 if ( s->pict_type == FF_P_TYPE |
2496 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
2979 | 2497 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
2498 } | |
2499 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 2500 if(!s->progressive_sequence){ |
1659 | 2501 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); |
697 | 2502 put_bits(&s->pb, 1, s->alternate_scan); |
2503 } | |
263 | 2504 //FIXME sprite stuff |
0 | 2505 |
2506 put_bits(&s->pb, 5, s->qscale); | |
2507 | |
6481 | 2508 if (s->pict_type != FF_I_TYPE) |
2979 | 2509 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ |
6481 | 2510 if (s->pict_type == FF_B_TYPE) |
2979 | 2511 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ |
0 | 2512 // printf("****frame %d\n", picture_number); |
2513 } | |
2514 | |
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
|
2515 #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
|
2516 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2517 /** |
1034 | 2518 * predicts the dc. |
2003 | 2519 * encoding quantized level -> quantized diff |
2967 | 2520 * decoding quantized diff -> quantized level |
1034 | 2521 * @param n block index (0-3 are luma, 4-5 are chroma) |
2522 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
2523 */ | |
2003 | 2524 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) |
0 | 2525 { |
2003 | 2526 int a, b, c, wrap, pred, scale, ret; |
3781 | 2527 int16_t *dc_val; |
0 | 2528 |
2529 /* find prediction */ | |
2530 if (n < 4) { | |
2979 | 2531 scale = s->y_dc_scale; |
0 | 2532 } else { |
2979 | 2533 scale = s->c_dc_scale; |
0 | 2534 } |
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
|
2535 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
|
2536 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
|
2537 |
266 | 2538 wrap= s->block_wrap[n]; |
2539 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 2540 |
2541 /* B C | |
2967 | 2542 * A X |
0 | 2543 */ |
266 | 2544 a = dc_val[ - 1]; |
2545 b = dc_val[ - 1 - wrap]; | |
2546 c = dc_val[ - wrap]; | |
0 | 2547 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2548 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2549 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2550 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2551 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
|
2552 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2553 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
|
2554 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2555 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2556 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2557 |
0 | 2558 if (abs(a - b) < abs(b - c)) { |
2979 | 2559 pred = c; |
0 | 2560 *dir_ptr = 1; /* top */ |
2561 } else { | |
2979 | 2562 pred = a; |
0 | 2563 *dir_ptr = 0; /* left */ |
2564 } | |
2565 /* 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
|
2566 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 2567 |
2003 | 2568 if(encoding){ |
2569 ret = level - pred; | |
2570 }else{ | |
2571 level += pred; | |
2572 ret= level; | |
7831 | 2573 if(s->error_recognition>=3){ |
2003 | 2574 if(level<0){ |
2575 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
2576 return -1; | |
2577 } | |
2578 if(level*scale > 2048 + scale){ | |
2579 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
2580 return -1; | |
2581 } | |
2582 } | |
2583 } | |
2584 level *=scale; | |
2004 | 2585 if(level&(~2047)){ |
2967 | 2586 if(level<0) |
2004 | 2587 level=0; |
2588 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP)) | |
2589 level=2047; | |
2590 } | |
2003 | 2591 dc_val[0]= level; |
2592 | |
2593 return ret; | |
0 | 2594 } |
2595 | |
1034 | 2596 /** |
2597 * predicts the ac. | |
2598 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2599 * @param dir the ac prediction direction | |
2600 */ | |
1008 | 2601 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 2602 int dir) |
2603 { | |
266 | 2604 int i; |
1064 | 2605 int16_t *ac_val, *ac_val1; |
903 | 2606 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2607 |
2608 /* find prediction */ | |
266 | 2609 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 2610 ac_val1 = ac_val; |
2611 if (s->ac_pred) { | |
2612 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
|
2613 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 2614 /* left prediction */ |
2615 ac_val -= 16; | |
2967 | 2616 |
903 | 2617 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 2618 /* same qscale */ |
2619 for(i=1;i<8;i++) { | |
1092 | 2620 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 2621 } |
2622 }else{ | |
2623 /* different qscale, we must rescale */ | |
2624 for(i=1;i<8;i++) { | |
1092 | 2625 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 2626 } |
0 | 2627 } |
2628 } 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
|
2629 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 2630 /* top prediction */ |
266 | 2631 ac_val -= 16 * s->block_wrap[n]; |
575 | 2632 |
903 | 2633 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 2634 /* same qscale */ |
2635 for(i=1;i<8;i++) { | |
1092 | 2636 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 2637 } |
2638 }else{ | |
2639 /* different qscale, we must rescale */ | |
2640 for(i=1;i<8;i++) { | |
1092 | 2641 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 2642 } |
0 | 2643 } |
2644 } | |
2645 } | |
2646 /* left copy */ | |
2647 for(i=1;i<8;i++) | |
1092 | 2648 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 2649 |
0 | 2650 /* top copy */ |
2651 for(i=1;i<8;i++) | |
1092 | 2652 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 2653 |
0 | 2654 } |
2655 | |
8590 | 2656 #if CONFIG_ENCODERS |
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
|
2657 |
1034 | 2658 /** |
2659 * encodes the dc value. | |
2660 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2661 */ | |
453 | 2662 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
|
2663 { |
293 | 2664 #if 1 |
453 | 2665 // if(level<-255 || level>255) printf("dc overflow\n"); |
293 | 2666 level+=256; |
2667 if (n < 4) { | |
2979 | 2668 /* luminance */ |
2669 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); | |
293 | 2670 } else { |
2979 | 2671 /* chrominance */ |
2672 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); | |
293 | 2673 } |
2674 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2675 int size, v; |
0 | 2676 /* find number of bits */ |
2677 size = 0; | |
2678 v = abs(level); | |
2679 while (v) { | |
2979 | 2680 v >>= 1; |
2681 size++; | |
0 | 2682 } |
2683 | |
2684 if (n < 4) { | |
2979 | 2685 /* luminance */ |
2686 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
0 | 2687 } else { |
2979 | 2688 /* chrominance */ |
2689 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
0 | 2690 } |
2691 | |
2692 /* encode remaining bits */ | |
2693 if (size > 0) { | |
2979 | 2694 if (level < 0) |
2695 level = (-level) ^ ((1 << size) - 1); | |
2696 put_bits(&s->pb, size, level); | |
2697 if (size > 8) | |
2698 put_bits(&s->pb, 1, 1); | |
0 | 2699 } |
293 | 2700 #endif |
0 | 2701 } |
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
|
2702 |
2502 | 2703 static inline int mpeg4_get_dc_length(int level, int n){ |
2704 if (n < 4) { | |
2705 return uni_DCtab_lum_len[level + 256]; | |
2706 } else { | |
2707 return uni_DCtab_chrom_len[level + 256]; | |
2708 } | |
2709 } | |
2710 | |
1034 | 2711 /** |
2712 * encodes a 8x8 block | |
2713 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2714 */ | |
2967 | 2715 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2716 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2717 { |
751 | 2718 int i, last_non_zero; |
2719 #if 0 //variables for the outcommented version | |
2720 int code, sign, last; | |
2721 #endif | |
0 | 2722 const RLTable *rl; |
1064 | 2723 uint32_t *bits_tab; |
2724 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
|
2725 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
|
2726 |
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
|
2727 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
2979 | 2728 /* mpeg4 based DC predictor */ |
2729 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
|
2730 if(last_index<1) return; |
2979 | 2731 i = 1; |
0 | 2732 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
|
2733 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
|
2734 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2735 } 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
|
2736 if(last_index<0) return; |
2979 | 2737 i = 0; |
0 | 2738 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
|
2739 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
|
2740 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2741 } |
2742 | |
2743 /* AC coefs */ | |
2744 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
|
2745 #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
|
2746 for (; i < last_index; i++) { |
2979 | 2747 int level = block[ scan_table[i] ]; |
2748 if (level) { | |
2749 int run = i - last_non_zero - 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
|
2750 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
|
2751 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
|
2752 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
|
2753 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
|
2754 }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
|
2755 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
|
2756 } |
2979 | 2757 last_non_zero = i; |
2758 } | |
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
|
2759 } |
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
|
2760 /*if(i<=last_index)*/{ |
2979 | 2761 int level = block[ scan_table[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
|
2762 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
|
2763 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
|
2764 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
|
2765 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
|
2766 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
|
2767 }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
|
2768 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
|
2769 } |
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
|
2770 } |
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
|
2771 #else |
0 | 2772 for (; i <= last_index; i++) { |
2979 | 2773 const int slevel = block[ scan_table[i] ]; |
2774 if (slevel) { | |
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
|
2775 int level; |
2979 | 2776 int run = i - last_non_zero - 1; |
2777 last = (i == last_index); | |
2778 sign = 0; | |
2779 level = slevel; | |
2780 if (level < 0) { | |
2781 sign = 1; | |
2782 level = -level; | |
2783 } | |
0 | 2784 code = get_rl_index(rl, last, run, level); |
453 | 2785 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2786 if (code == rl->n) { |
2787 int level1, run1; | |
2788 level1 = level - rl->max_level[last][run]; | |
2967 | 2789 if (level1 < 1) |
0 | 2790 goto esc2; |
2791 code = get_rl_index(rl, last, run, level1); | |
2792 if (code == rl->n) { | |
2793 esc2: | |
453 | 2794 put_bits(ac_pb, 1, 1); |
0 | 2795 if (level > MAX_LEVEL) |
2796 goto esc3; | |
2797 run1 = run - rl->max_run[last][level] - 1; | |
2798 if (run1 < 0) | |
2799 goto esc3; | |
2800 code = get_rl_index(rl, last, run1, level); | |
2801 if (code == rl->n) { | |
2802 esc3: | |
2803 /* third escape */ | |
453 | 2804 put_bits(ac_pb, 1, 1); |
2805 put_bits(ac_pb, 1, last); | |
2806 put_bits(ac_pb, 6, run); | |
2807 put_bits(ac_pb, 1, 1); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2808 put_sbits(ac_pb, 12, slevel); |
453 | 2809 put_bits(ac_pb, 1, 1); |
0 | 2810 } else { |
2811 /* second escape */ | |
453 | 2812 put_bits(ac_pb, 1, 0); |
2813 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2814 put_bits(ac_pb, 1, sign); | |
0 | 2815 } |
2816 } else { | |
2817 /* first escape */ | |
453 | 2818 put_bits(ac_pb, 1, 0); |
2819 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2820 put_bits(ac_pb, 1, sign); | |
0 | 2821 } |
2822 } else { | |
453 | 2823 put_bits(ac_pb, 1, sign); |
0 | 2824 } |
2979 | 2825 last_non_zero = i; |
2826 } | |
0 | 2827 } |
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
|
2828 #endif |
0 | 2829 } |
936 | 2830 |
2967 | 2831 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2832 uint8_t *scan_table) |
936 | 2833 { |
2834 int i, last_non_zero; | |
2835 const RLTable *rl; | |
1064 | 2836 uint8_t *len_tab; |
936 | 2837 const int last_index = s->block_last_index[n]; |
2838 int len=0; | |
2839 | |
2840 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2979 | 2841 /* mpeg4 based DC predictor */ |
2842 len += mpeg4_get_dc_length(intra_dc, n); | |
936 | 2843 if(last_index<1) return len; |
2979 | 2844 i = 1; |
936 | 2845 rl = &rl_intra; |
2846 len_tab = uni_mpeg4_intra_rl_len; | |
2847 } else { | |
2848 if(last_index<0) return 0; | |
2979 | 2849 i = 0; |
936 | 2850 rl = &rl_inter; |
2851 len_tab = uni_mpeg4_inter_rl_len; | |
2852 } | |
2853 | |
2854 /* AC coefs */ | |
2855 last_non_zero = i - 1; | |
2856 for (; i < last_index; i++) { | |
2979 | 2857 int level = block[ scan_table[i] ]; |
2858 if (level) { | |
2859 int run = i - last_non_zero - 1; | |
936 | 2860 level+=64; |
2861 if((level&(~127)) == 0){ | |
2862 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2863 len += len_tab[index]; | |
2864 }else{ //ESC3 | |
2865 len += 7+2+1+6+1+12+1; | |
2866 } | |
2979 | 2867 last_non_zero = i; |
2868 } | |
936 | 2869 } |
2870 /*if(i<=last_index)*/{ | |
2979 | 2871 int level = block[ scan_table[i] ]; |
936 | 2872 int run = i - last_non_zero - 1; |
2873 level+=64; | |
2874 if((level&(~127)) == 0){ | |
2875 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2876 len += len_tab[index]; | |
2877 }else{ //ESC3 | |
2878 len += 7+2+1+6+1+12+1; | |
2879 } | |
2880 } | |
2967 | 2881 |
936 | 2882 return len; |
2883 } | |
2884 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2885 #endif |
0 | 2886 |
2887 | |
2888 /***********************************************/ | |
2889 /* decoding */ | |
2890 | |
2891 static VLC intra_MCBPC_vlc; | |
2892 static VLC inter_MCBPC_vlc; | |
2893 static VLC cbpy_vlc; | |
2894 static VLC mv_vlc; | |
2895 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2896 static VLC sprite_trajectory; |
262 | 2897 static VLC mb_type_b_vlc; |
1655 | 2898 static VLC h263_mbtype_b_vlc; |
2899 static VLC cbpc_b_vlc; | |
0 | 2900 |
2901 /* init vlcs */ | |
2902 | |
2903 /* XXX: find a better solution to handle static init */ | |
2904 void h263_decode_init_vlc(MpegEncContext *s) | |
2905 { | |
2906 static int done = 0; | |
2907 | |
2908 if (!done) { | |
2909 done = 1; | |
2910 | |
7098 | 2911 INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
0 | 2912 intra_MCBPC_bits, 1, 1, |
7098 | 2913 intra_MCBPC_code, 1, 1, 72); |
2914 INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, | |
0 | 2915 inter_MCBPC_bits, 1, 1, |
7098 | 2916 inter_MCBPC_code, 1, 1, 198); |
2917 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16, | |
0 | 2918 &cbpy_tab[0][1], 2, 1, |
7098 | 2919 &cbpy_tab[0][0], 2, 1, 64); |
2920 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, | |
0 | 2921 &mvtab[0][1], 2, 1, |
7098 | 2922 &mvtab[0][0], 2, 1, 538); |
4668 | 2923 init_rl(&rl_inter, static_rl_table_store[0]); |
2924 init_rl(&rl_intra, static_rl_table_store[1]); | |
2925 init_rl(&rvlc_rl_inter, static_rl_table_store[3]); | |
2926 init_rl(&rvlc_rl_intra, static_rl_table_store[4]); | |
2927 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
6940
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2928 INIT_VLC_RL(rl_inter, 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2929 INIT_VLC_RL(rl_intra, 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2930 INIT_VLC_RL(rvlc_rl_inter, 1072); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2931 INIT_VLC_RL(rvlc_rl_intra, 1072); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2932 INIT_VLC_RL(rl_intra_aic, 554); |
7098 | 2933 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2934 &DCtab_lum[0][1], 2, 1, |
7098 | 2935 &DCtab_lum[0][0], 2, 1, 512); |
2936 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, | |
0 | 2937 &DCtab_chrom[0][1], 2, 1, |
7098 | 2938 &DCtab_chrom[0][0], 2, 1, 512); |
2939 INIT_VLC_STATIC(&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
|
2940 &sprite_trajectory_tab[0][1], 4, 2, |
7098 | 2941 &sprite_trajectory_tab[0][0], 4, 2, 128); |
2942 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, | |
262 | 2943 &mb_type_b_tab[0][1], 2, 1, |
7098 | 2944 &mb_type_b_tab[0][0], 2, 1, 16); |
2945 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, | |
1655 | 2946 &h263_mbtype_b_tab[0][1], 2, 1, |
7098 | 2947 &h263_mbtype_b_tab[0][0], 2, 1, 80); |
2948 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, | |
1655 | 2949 &cbpc_b_tab[0][1], 2, 1, |
7098 | 2950 &cbpc_b_tab[0][0], 2, 1, 8); |
0 | 2951 } |
2952 } | |
2953 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2954 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2955 * 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
|
2956 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2957 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
|
2958 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2959 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2960 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2961 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2962 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2963 return 4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2964 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2965 |
1661 | 2966 int ff_h263_decode_mba(MpegEncContext *s) |
2967 { | |
2968 int i, mb_pos; | |
2969 | |
2970 for(i=0; i<6; i++){ | |
1670 | 2971 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2972 } |
2973 mb_pos= get_bits(&s->gb, ff_mba_length[i]); | |
2974 s->mb_x= mb_pos % s->mb_width; | |
2975 s->mb_y= mb_pos / s->mb_width; | |
2976 | |
2977 return mb_pos; | |
2978 } | |
2979 | |
2980 void ff_h263_encode_mba(MpegEncContext *s) | |
2981 { | |
2982 int i, mb_pos; | |
2983 | |
2984 for(i=0; i<6; i++){ | |
1670 | 2985 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2986 } |
2987 mb_pos= s->mb_x + s->mb_width*s->mb_y; | |
2988 put_bits(&s->pb, ff_mba_length[i], mb_pos); | |
2989 } | |
2990 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2991 /** |
1661 | 2992 * decodes the group of blocks header or slice header. |
6524 | 2993 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2994 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2995 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 2996 { |
1661 | 2997 unsigned int val, gfid, gob_number; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2998 int left; |
2967 | 2999 |
162 | 3000 /* Check for GOB Start Code */ |
3001 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3002 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3003 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3004 |
162 | 3005 /* 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
|
3006 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
|
3007 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
|
3008 //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
|
3009 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3010 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
|
3011 } |
2967 | 3012 if(left<=13) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3013 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3014 |
1661 | 3015 if(s->h263_slice_structured){ |
3016 if(get_bits1(&s->gb)==0) | |
3017 return -1; | |
3018 | |
3019 ff_h263_decode_mba(s); | |
3020 | |
3021 if(s->mb_num > 1583) | |
3022 if(get_bits1(&s->gb)==0) | |
3023 return -1; | |
2967 | 3024 |
1661 | 3025 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
3026 if(get_bits1(&s->gb)==0) | |
3027 return -1; | |
3028 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3029 }else{ | |
3030 gob_number = get_bits(&s->gb, 5); /* GN */ | |
3031 s->mb_x= 0; | |
3032 s->mb_y= s->gob_index* gob_number; | |
3033 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3034 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
3035 } | |
2967 | 3036 |
3037 if(s->mb_y >= s->mb_height) | |
1661 | 3038 return -1; |
3039 | |
2967 | 3040 if(s->qscale==0) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3041 return -1; |
1644 | 3042 |
162 | 3043 return 0; |
3044 } | |
3045 | |
290 | 3046 static inline void memsetw(short *tab, int val, int n) |
3047 { | |
3048 int i; | |
3049 for(i=0;i<n;i++) | |
3050 tab[i] = val; | |
3051 } | |
3052 | |
8590 | 3053 #if CONFIG_ENCODERS |
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
|
3054 |
453 | 3055 void ff_mpeg4_init_partitions(MpegEncContext *s) |
3056 { | |
1799 | 3057 uint8_t *start= pbBufPtr(&s->pb); |
3058 uint8_t *end= s->pb.buf_end; | |
3059 int size= end - start; | |
2437
8a30df830ad6
x86_64 pointer typecast fix by (Martin Drab <drab kepler.fjfi.cvut cz>)
michael
parents:
2422
diff
changeset
|
3060 int pb_size = (((long)start + size/3)&(~3)) - (long)start; |
1912 | 3061 int tex_size= (size - 2*pb_size)&(~3); |
2967 | 3062 |
1799 | 3063 set_put_bits_buffer_size(&s->pb, pb_size); |
3064 init_put_bits(&s->tex_pb, start + pb_size , tex_size); | |
1910
5c21b165abf6
ensure that the bitstream buffers for encoding partitioned frames are aligned
michael
parents:
1896
diff
changeset
|
3065 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size); |
453 | 3066 } |
3067 | |
3068 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 3069 { |
1786 | 3070 const int pb2_len = put_bits_count(&s->pb2 ); |
3071 const int tex_pb_len= put_bits_count(&s->tex_pb); | |
3072 const int bits= put_bits_count(&s->pb); | |
453 | 3073 |
6481 | 3074 if(s->pict_type==FF_I_TYPE){ |
453 | 3075 put_bits(&s->pb, 19, DC_MARKER); |
3076 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
3077 s->i_tex_bits+= tex_pb_len; | |
3078 }else{ | |
3079 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
|
3080 s->misc_bits+=17 + pb2_len; |
453 | 3081 s->mv_bits+= bits - s->last_bits; |
3082 s->p_tex_bits+= tex_pb_len; | |
3083 } | |
3084 | |
3085 flush_put_bits(&s->pb2); | |
3086 flush_put_bits(&s->tex_pb); | |
3087 | |
1799 | 3088 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf); |
3089 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len); | |
3090 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len); | |
1786 | 3091 s->last_bits= put_bits_count(&s->pb); |
453 | 3092 } |
3093 | |
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
|
3094 #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
|
3095 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3096 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
|
3097 switch(s->pict_type){ |
6481 | 3098 case FF_I_TYPE: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3099 return 16; |
6481 | 3100 case FF_P_TYPE: |
3101 case FF_S_TYPE: | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3102 return s->f_code+15; |
6481 | 3103 case FF_B_TYPE: |
6655
22cca5d3173a
Implement FFMAX3(a,b,c) - maximum over three arguments.
voroshil
parents:
6524
diff
changeset
|
3104 return FFMAX3(s->f_code, s->b_code, 2) + 15; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3105 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3106 return -1; |
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 |
8590 | 3110 #if CONFIG_ENCODERS |
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
|
3111 |
453 | 3112 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
3113 { | |
3114 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
3115 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3116 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 3117 put_bits(&s->pb, 1, 1); |
2967 | 3118 |
453 | 3119 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
|
3120 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 3121 put_bits(&s->pb, 1, 0); /* no HEC */ |
3122 } | |
3123 | |
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
|
3124 #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
|
3125 |
453 | 3126 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3127 * 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
|
3128 * @return 0 if not |
453 | 3129 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3130 static inline int mpeg4_is_resync(MpegEncContext *s){ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3131 int bits_count= get_bits_count(&s->gb); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3132 int v= show_bits(&s->gb, 16); |
2967 | 3133 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3134 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
|
3135 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3136 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3137 |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3138 while(v<=0xFF){ |
6481 | 3139 if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame) |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3140 break; |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3141 skip_bits(&s->gb, 8+s->pict_type); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3142 bits_count+= 8+s->pict_type; |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3143 v= show_bits(&s->gb, 16); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3144 } |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3145 |
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
|
3146 if(bits_count + 8 >= s->gb.size_in_bits){ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3147 v>>=8; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3148 v|= 0x7F >> (7-(bits_count&7)); |
2967 | 3149 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3150 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3151 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3152 }else{ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3153 if(v == ff_mpeg4_resync_prefix[bits_count&7]){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3154 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3155 GetBitContext gb= s->gb; |
2967 | 3156 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3157 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3158 align_get_bits(&s->gb); |
2967 | 3159 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3160 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3161 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3162 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3163 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3164 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3165 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3166 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
|
3167 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3168 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3169 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3170 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3171 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3172 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3173 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3174 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3175 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3176 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3177 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 3178 { |
290 | 3179 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
|
3180 int header_extension=0, mb_num, len; |
2967 | 3181 |
453 | 3182 /* 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
|
3183 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
|
3184 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3185 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3186 if(get_bits1(&s->gb)) break; |
453 | 3187 } |
3188 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3189 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3190 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); |
453 | 3191 return -1; |
3192 } | |
2967 | 3193 |
453 | 3194 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3195 header_extension= get_bits1(&s->gb); |
453 | 3196 //FIXME more stuff here |
3197 } | |
3198 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3199 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
|
3200 if(mb_num>=s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3201 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 3202 return -1; |
3203 } | |
6481 | 3204 if(s->pict_type == FF_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
|
3205 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
6497 | 3206 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded |
1176 | 3207 } |
2967 | 3208 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3209 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
|
3210 s->mb_y= mb_num / s->mb_width; |
453 | 3211 |
3212 if(s->shape != BIN_ONLY_SHAPE){ | |
2967 | 3213 int qscale= get_bits(&s->gb, s->quant_precision); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3214 if(qscale) |
1644 | 3215 s->chroma_qscale=s->qscale= qscale; |
290 | 3216 } |
3217 | |
3218 if(s->shape == RECT_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3219 header_extension= get_bits1(&s->gb); |
290 | 3220 } |
3221 if(header_extension){ | |
453 | 3222 int time_increment; |
290 | 3223 int time_incr=0; |
453 | 3224 |
2967 | 3225 while (get_bits1(&s->gb) != 0) |
290 | 3226 time_incr++; |
3227 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3228 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
|
3229 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
|
3230 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
2967 | 3231 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3232 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 3233 //FIXME not rect stuff here |
3234 | |
3235 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3236 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
3237 //FIXME don't just ignore everything |
6481 | 3238 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1914 | 3239 mpeg4_decode_sprite_trajectory(s, &s->gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3240 av_log(s->avctx, AV_LOG_ERROR, "untested\n"); |
290 | 3241 } |
3242 | |
3243 //FIXME reduced res stuff here | |
2967 | 3244 |
6481 | 3245 if (s->pict_type != FF_I_TYPE) { |
2979 | 3246 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 3247 if(f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3248 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); |
290 | 3249 } |
3250 } | |
6481 | 3251 if (s->pict_type == FF_B_TYPE) { |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3252 int b_code = get_bits(&s->gb, 3); |
660 | 3253 if(b_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3254 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); |
660 | 3255 } |
2967 | 3256 } |
290 | 3257 } |
3258 } | |
3259 //FIXME new-pred stuff | |
2967 | 3260 |
453 | 3261 //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)); |
3262 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3263 return 0; |
453 | 3264 } |
3265 | |
3266 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
3267 { | |
3268 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 3269 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3270 l_wrap= s->b8_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3271 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3272 c_wrap= s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3273 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1; |
290 | 3274 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3275 #if 0 |
290 | 3276 /* clean DC */ |
453 | 3277 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
3278 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
3279 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
|
3280 #endif |
290 | 3281 |
3282 /* clean AC */ | |
1064 | 3283 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
3284 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
3285 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 3286 |
3287 /* clean MV */ | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
3288 // we can't clear the MVs as they might be needed by a b frame |
1064 | 3289 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
3290 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 3291 s->last_mv[0][0][0]= |
3292 s->last_mv[0][0][1]= | |
3293 s->last_mv[1][0][0]= | |
3294 s->last_mv[1][0][1]= 0; | |
3295 } | |
3296 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3297 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3298 * decodes the group of blocks / video packet header. |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3299 * @return bit position of the resync_marker, or <0 if none was found |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3300 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3301 int ff_h263_resync(MpegEncContext *s){ |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3302 int left, pos, ret; |
2967 | 3303 |
1521 | 3304 if(s->codec_id==CODEC_ID_MPEG4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3305 skip_bits1(&s->gb); |
1521 | 3306 align_get_bits(&s->gb); |
3307 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3308 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3309 if(show_bits(&s->gb, 16)==0){ |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3310 pos= get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3311 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3312 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3313 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3314 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3315 if(ret>=0) |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3316 return pos; |
453 | 3317 } |
5129 | 3318 //OK, it's not where it is supposed to be ... |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3319 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3320 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
|
3321 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
2967 | 3322 |
3323 for(;left>16+1+5+5; left-=8){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3324 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3325 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3326 |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3327 pos= get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3328 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3329 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3330 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3331 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3332 if(ret>=0) |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3333 return pos; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3334 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3335 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3336 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3337 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3338 } |
2967 | 3339 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3340 return -1; |
453 | 3341 } |
3342 | |
3343 /** | |
1034 | 3344 * gets the average motion vector for a GMC MB. |
753 | 3345 * @param n either 0 for the x component or 1 for y |
3346 * @returns the average MV for a GMC MB | |
3347 */ | |
3348 static inline int get_amv(MpegEncContext *s, int n){ | |
3349 int x, y, mb_v, sum, dx, dy, shift; | |
3350 int len = 1 << (s->f_code + 4); | |
3351 const int a= s->sprite_warping_accuracy; | |
2967 | 3352 |
1997 | 3353 if(s->workaround_bugs & FF_BUG_AMV) |
3354 len >>= s->quarter_sample; | |
753 | 3355 |
3356 if(s->real_sprite_warping_points==1){ | |
3357 if(s->divx_version==500 && s->divx_build==413) | |
3358 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
3359 else | |
3360 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
3361 }else{ | |
3362 dx= s->sprite_delta[n][0]; | |
3363 dy= s->sprite_delta[n][1]; | |
3364 shift= s->sprite_shift[0]; | |
3365 if(n) dy -= 1<<(shift + a + 1); | |
3366 else dx -= 1<<(shift + a + 1); | |
3367 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
3368 | |
3369 sum=0; | |
3370 for(y=0; y<16; y++){ | |
3371 int v; | |
2967 | 3372 |
753 | 3373 v= mb_v + dy*y; |
3374 //XXX FIXME optimize | |
3375 for(x=0; x<16; x++){ | |
3376 sum+= v>>shift; | |
3377 v+= dx; | |
3378 } | |
3379 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
3380 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 3381 } |
3382 | |
3383 if (sum < -len) sum= -len; | |
3384 else if (sum >= len) sum= len-1; | |
3385 | |
3386 return sum; | |
3387 } | |
3388 | |
3389 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3390 * decodes first partition. |
6524 | 3391 * @return number of MBs decoded or <0 if an error occurred |
453 | 3392 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3393 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
|
3394 int mb_num; |
1064 | 3395 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
2967 | 3396 |
453 | 3397 /* decode first partition */ |
3398 mb_num=0; | |
290 | 3399 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3400 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
|
3401 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3402 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
|
3403 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3404 int cbpc; |
3405 int dir=0; | |
2967 | 3406 |
453 | 3407 mb_num++; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3408 ff_update_block_index(s); |
453 | 3409 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
3410 s->first_slice_line=0; | |
2967 | 3411 |
6481 | 3412 if(s->pict_type==FF_I_TYPE){ |
453 | 3413 int i; |
3414 | |
1482 | 3415 do{ |
1873 | 3416 if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
3417 return mb_num-1; | |
3418 } | |
3419 | |
1482 | 3420 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
3421 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3422 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
1482 | 3423 return -1; |
3424 } | |
3425 }while(cbpc == 8); | |
2967 | 3426 |
453 | 3427 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
|
3428 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3429 s->mb_intra = 1; |
3430 | |
3431 if(cbpc & 4) { | |
1652 | 3432 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3433 } |
903 | 3434 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3435 |
3436 s->mbintra_table[xy]= 1; | |
3437 for(i=0; i<6; i++){ | |
3438 int dc_pred_dir; | |
2967 | 3439 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3440 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3441 av_log(s->avctx, AV_LOG_ERROR, "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
|
3442 return -1; |
453 | 3443 } |
3444 dir<<=1; | |
3445 if(dc_pred_dir) dir|=1; | |
3446 } | |
3447 s->pred_dir_table[xy]= dir; | |
3448 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3449 int mx, my, pred_x, pred_y, bits; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3450 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]]; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3451 const int stride= s->b8_stride*2; |
453 | 3452 |
1873 | 3453 try_again: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3454 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3455 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3456 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3457 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3458 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3459 if(bits&0x10000){ |
453 | 3460 /* skip mb */ |
6481 | 3461 if(s->pict_type==FF_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
|
3462 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 3463 mx= get_amv(s, 0); |
3464 my= get_amv(s, 1); | |
453 | 3465 }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
|
3466 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3467 mx=my=0; |
453 | 3468 } |
3469 mot_val[0 ]= mot_val[2 ]= | |
3470 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3471 mot_val[1 ]= mot_val[3 ]= | |
3472 mot_val[1+stride]= mot_val[3+stride]= my; | |
3473 | |
3474 if(s->mbintra_table[xy]) | |
3475 ff_clean_intra_table_entries(s); | |
3476 continue; | |
3477 } | |
1482 | 3478 |
544 | 3479 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 3480 if (cbpc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3481 av_log(s->avctx, AV_LOG_ERROR, "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
|
3482 return -1; |
453 | 3483 } |
1873 | 3484 if(cbpc == 20) |
3485 goto try_again; | |
1482 | 3486 |
453 | 3487 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
2967 | 3488 |
453 | 3489 s->mb_intra = ((cbpc & 4) != 0); |
2967 | 3490 |
453 | 3491 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
|
3492 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3493 s->mbintra_table[xy]= 1; |
2967 | 3494 mot_val[0 ]= mot_val[2 ]= |
453 | 3495 mot_val[0+stride]= mot_val[2+stride]= 0; |
3496 mot_val[1 ]= mot_val[3 ]= | |
3497 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3498 }else{ | |
3499 if(s->mbintra_table[xy]) | |
3500 ff_clean_intra_table_entries(s); | |
3501 | |
6481 | 3502 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
453 | 3503 s->mcsel= get_bits1(&s->gb); |
3504 else s->mcsel= 0; | |
2967 | 3505 |
453 | 3506 if ((cbpc & 16) == 0) { |
3507 /* 16x16 motion prediction */ | |
3508 | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3509 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
753 | 3510 if(!s->mcsel){ |
3511 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3512 if (mx >= 0xffff) | |
3513 return -1; | |
3514 | |
3515 my = h263_decode_motion(s, pred_y, s->f_code); | |
3516 if (my >= 0xffff) | |
3517 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
|
3518 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3519 } else { |
3520 mx = get_amv(s, 0); | |
3521 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
|
3522 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 3523 } |
753 | 3524 |
453 | 3525 mot_val[0 ]= mot_val[2 ] = |
3526 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3527 mot_val[1 ]= mot_val[3 ]= | |
3528 mot_val[1+stride]= mot_val[3+stride]= my; | |
3529 } else { | |
3530 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
|
3531 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 3532 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3533 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
453 | 3534 mx = h263_decode_motion(s, pred_x, s->f_code); |
3535 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3536 return -1; |
2967 | 3537 |
453 | 3538 my = h263_decode_motion(s, pred_y, s->f_code); |
3539 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3540 return -1; |
453 | 3541 mot_val[0] = mx; |
3542 mot_val[1] = my; | |
3543 } | |
3544 } | |
3545 } | |
3546 } | |
3547 } | |
3548 s->mb_x= 0; | |
3549 } | |
3550 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3551 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3552 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3553 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3554 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3555 * decode second partition. |
6524 | 3556 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3557 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3558 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
|
3559 int mb_num=0; |
1064 | 3560 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
|
3561 |
453 | 3562 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
|
3563 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3564 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
|
3565 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3566 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
|
3567 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3568 |
3569 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3570 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3571 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
|
3572 s->first_slice_line=0; |
2967 | 3573 |
6481 | 3574 if(s->pict_type==FF_I_TYPE){ |
453 | 3575 int ac_pred= get_bits1(&s->gb); |
544 | 3576 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3577 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3578 av_log(s->avctx, AV_LOG_ERROR, "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
|
3579 return -1; |
453 | 3580 } |
2967 | 3581 |
453 | 3582 s->cbp_table[xy]|= cbpy<<2; |
2967 | 3583 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 3584 }else{ /* P || S_TYPE */ |
2967 | 3585 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 3586 int dir=0,i; |
3587 int ac_pred = get_bits1(&s->gb); | |
544 | 3588 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3589 |
3590 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3591 av_log(s->avctx, AV_LOG_ERROR, "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
|
3592 return -1; |
453 | 3593 } |
2967 | 3594 |
453 | 3595 if(s->cbp_table[xy] & 8) { |
1652 | 3596 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3597 } |
903 | 3598 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3599 |
3600 for(i=0; i<6; i++){ | |
3601 int dc_pred_dir; | |
2967 | 3602 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3603 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3604 av_log(s->avctx, AV_LOG_ERROR, "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
|
3605 return -1; |
453 | 3606 } |
3607 dir<<=1; | |
3608 if(dc_pred_dir) dir|=1; | |
3609 } | |
3610 s->cbp_table[xy]&= 3; //remove dquant | |
3611 s->cbp_table[xy]|= cbpy<<2; | |
2967 | 3612 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3613 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
|
3614 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 3615 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3616 s->cbp_table[xy]= 0; |
3617 }else{ | |
544 | 3618 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3619 |
3620 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3621 av_log(s->avctx, AV_LOG_ERROR, "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
|
3622 return -1; |
453 | 3623 } |
2967 | 3624 |
453 | 3625 if(s->cbp_table[xy] & 8) { |
1652 | 3626 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3627 } |
903 | 3628 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3629 |
3630 s->cbp_table[xy]&= 3; //remove dquant | |
3631 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3632 } | |
3633 } | |
3634 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3635 if(mb_num >= mb_count) return 0; |
453 | 3636 s->mb_x= 0; |
3637 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3638 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3639 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3640 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3641 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3642 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3643 * @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
|
3644 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3645 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3646 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3647 int mb_num; |
6481 | 3648 const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
3649 const int part_a_end = s->pict_type==FF_I_TYPE ? (DC_END |MV_END) : MV_END; | |
2967 | 3650 |
3651 mb_num= mpeg4_decode_partition_a(s); | |
1144 | 3652 if(mb_num<0){ |
3653 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
|
3654 return -1; |
1144 | 3655 } |
2967 | 3656 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3657 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3658 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); |
1144 | 3659 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
|
3660 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3661 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3662 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3663 s->mb_num_left= mb_num; |
2967 | 3664 |
6481 | 3665 if(s->pict_type==FF_I_TYPE){ |
1873 | 3666 while(show_bits(&s->gb, 9) == 1) |
3667 skip_bits(&s->gb, 9); | |
1257 | 3668 if(get_bits_long(&s->gb, 19)!=DC_MARKER){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3669 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition 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
|
3670 return -1; |
1144 | 3671 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3672 }else{ |
1873 | 3673 while(show_bits(&s->gb, 10) == 1) |
3674 skip_bits(&s->gb, 10); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3675 if(get_bits(&s->gb, 17)!=MOTION_MARKER){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3676 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition 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
|
3677 return -1; |
1144 | 3678 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3679 } |
1144 | 3680 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); |
2967 | 3681 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3682 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
6481 | 3683 if(s->pict_type==FF_P_TYPE) |
1144 | 3684 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
|
3685 return -1; |
1144 | 3686 }else{ |
6481 | 3687 if(s->pict_type==FF_P_TYPE) |
1144 | 3688 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
|
3689 } |
453 | 3690 |
2967 | 3691 return 0; |
453 | 3692 } |
3693 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3694 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3695 * decode partition C of one MB. |
6524 | 3696 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3697 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3698 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 3699 { |
3700 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
|
3701 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
|
3702 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3703 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
|
3704 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3705 |
3282 | 3706 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; |
3707 | |
903 | 3708 if(s->current_picture.qscale_table[xy] != s->qscale){ |
1652 | 3709 ff_set_qscale(s, s->current_picture.qscale_table[xy] ); |
453 | 3710 } |
2967 | 3711 |
6481 | 3712 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { |
453 | 3713 int i; |
3714 for(i=0; i<4; i++){ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3715 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3716 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
453 | 3717 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3718 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
|
3719 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3720 if (IS_SKIP(mb_type)) { |
453 | 3721 /* skip mb */ |
3722 for(i=0;i<6;i++) | |
3723 s->block_last_index[i] = -1; | |
3724 s->mv_dir = MV_DIR_FORWARD; | |
3725 s->mv_type = MV_TYPE_16X16; | |
6481 | 3726 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
453 | 3727 s->mcsel=1; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3728 s->mb_skipped = 0; |
453 | 3729 }else{ |
3730 s->mcsel=0; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3731 s->mb_skipped = 1; |
453 | 3732 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3733 }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
|
3734 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3735 }else if(!s->mb_intra){ |
3736 // s->mcsel= 0; //FIXME do we need to init that | |
2967 | 3737 |
453 | 3738 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
|
3739 if (IS_8X8(mb_type)) { |
453 | 3740 s->mv_type = MV_TYPE_8X8; |
3741 } else { | |
3742 s->mv_type = MV_TYPE_16X16; | |
3743 } | |
3744 } | |
3745 } else { /* I-Frame */ | |
3746 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
|
3747 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3748 } |
3749 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3750 if (!IS_SKIP(mb_type)) { |
1132 | 3751 int i; |
2632 | 3752 s->dsp.clear_blocks(s->block[0]); |
453 | 3753 /* decode each block */ |
3754 for (i = 0; i < 6; i++) { | |
1132 | 3755 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3756 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); |
453 | 3757 return -1; |
3758 } | |
718 | 3759 cbp+=cbp; |
453 | 3760 } |
3761 } | |
290 | 3762 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3763 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3764 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3765 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
|
3766 //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
|
3767 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3768 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3769 else |
2967 | 3770 return SLICE_NOEND; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3771 }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
|
3772 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
|
3773 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
|
3774 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
|
3775 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
|
3776 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3777 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3778 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3779 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3780 |
1633 | 3781 /** |
3782 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
3783 */ | |
3784 static void preview_obmc(MpegEncContext *s){ | |
3785 GetBitContext gb= s->gb; | |
2967 | 3786 |
1633 | 3787 int cbpc, i, pred_x, pred_y, mx, my; |
3788 int16_t *mot_val; | |
3789 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3790 const int stride= s->b8_stride*2; |
2967 | 3791 |
1633 | 3792 for(i=0; i<4; i++) |
3793 s->block_index[i]+= 2; | |
3794 for(i=4; i<6; i++) | |
3795 s->block_index[i]+= 1; | |
3796 s->mb_x++; | |
2967 | 3797 |
6481 | 3798 assert(s->pict_type == FF_P_TYPE); |
1633 | 3799 |
3800 do{ | |
3801 if (get_bits1(&s->gb)) { | |
3802 /* skip mb */ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3803 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; |
2967 | 3804 mot_val[0 ]= mot_val[2 ]= |
1633 | 3805 mot_val[0+stride]= mot_val[2+stride]= 0; |
3806 mot_val[1 ]= mot_val[3 ]= | |
3807 mot_val[1+stride]= mot_val[3+stride]= 0; | |
2967 | 3808 |
1633 | 3809 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
3810 goto end; | |
3811 } | |
3812 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
3813 }while(cbpc == 20); | |
2967 | 3814 |
1633 | 3815 if(cbpc & 4){ |
3816 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
3817 }else{ | |
3818 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3819 if (cbpc & 8) { | |
1656 | 3820 if(s->modified_quant){ |
3821 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
3822 else skip_bits(&s->gb, 5); | |
3823 }else | |
3824 skip_bits(&s->gb, 2); | |
1633 | 3825 } |
2967 | 3826 |
1633 | 3827 if ((cbpc & 16) == 0) { |
2967 | 3828 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
1633 | 3829 /* 16x16 motion prediction */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3830 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1633 | 3831 if (s->umvplus) |
3832 mx = h263p_decode_umotion(s, pred_x); | |
3833 else | |
1655 | 3834 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3835 |
1633 | 3836 if (s->umvplus) |
3837 my = h263p_decode_umotion(s, pred_y); | |
3838 else | |
1655 | 3839 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3840 |
3841 mot_val[0 ]= mot_val[2 ]= | |
1633 | 3842 mot_val[0+stride]= mot_val[2+stride]= mx; |
3843 mot_val[1 ]= mot_val[3 ]= | |
3844 mot_val[1+stride]= mot_val[3+stride]= my; | |
3845 } else { | |
2967 | 3846 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
1633 | 3847 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3848 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 3849 if (s->umvplus) |
3850 mx = h263p_decode_umotion(s, pred_x); | |
3851 else | |
1655 | 3852 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3853 |
1633 | 3854 if (s->umvplus) |
3855 my = h263p_decode_umotion(s, pred_y); | |
2967 | 3856 else |
1655 | 3857 my = h263_decode_motion(s, pred_y, 1); |
1633 | 3858 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
3859 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
3860 mot_val[0] = mx; | |
3861 mot_val[1] = my; | |
3862 } | |
3863 } | |
3864 } | |
3865 end: | |
2967 | 3866 |
1633 | 3867 for(i=0; i<4; i++) |
3868 s->block_index[i]-= 2; | |
3869 for(i=4; i<6; i++) | |
3870 s->block_index[i]-= 1; | |
3871 s->mb_x--; | |
3872 | |
3873 s->gb= gb; | |
3874 } | |
3875 | |
1656 | 3876 static void h263_decode_dquant(MpegEncContext *s){ |
3877 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
3878 | |
3879 if(s->modified_quant){ | |
3880 if(get_bits1(&s->gb)) | |
3881 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; | |
3882 else | |
3883 s->qscale= get_bits(&s->gb, 5); | |
3884 }else | |
3885 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
3886 ff_set_qscale(s, s->qscale); | |
3887 } | |
3888 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3889 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3890 DCTELEM block[6][64]) |
0 | 3891 { |
3892 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3893 int16_t *mot_val; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3894 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
2967 | 3895 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3896 assert(!s->h263_pred); |
2967 | 3897 |
6481 | 3898 if (s->pict_type == FF_P_TYPE) { |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3899 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3900 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3901 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3902 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3903 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3904 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3905 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3906 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
|
3907 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3908 s->mv[0][0][0] = 0; |
3909 s->mv[0][0][1] = 0; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3910 s->mb_skipped = !(s->obmc | s->loop_filter); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3911 goto end; |
255 | 3912 } |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3913 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3914 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3915 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3916 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3917 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3918 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3919 }while(cbpc == 20); |
2967 | 3920 |
2632 | 3921 s->dsp.clear_blocks(s->block[0]); |
2967 | 3922 |
0 | 3923 dquant = cbpc & 8; |
3924 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3925 if (s->mb_intra) goto intra; |
2967 | 3926 |
544 | 3927 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2967 | 3928 |
1637 | 3929 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
3930 cbpy ^= 0xF; | |
2967 | 3931 |
1637 | 3932 cbp = (cbpc & 3) | (cbpy << 2); |
0 | 3933 if (dquant) { |
1656 | 3934 h263_decode_dquant(s); |
0 | 3935 } |
2967 | 3936 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3937 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3938 if ((cbpc & 16) == 0) { |
2967 | 3939 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3940 /* 16x16 motion prediction */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3941 s->mv_type = MV_TYPE_16X16; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3942 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3943 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3944 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3945 else |
1655 | 3946 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3947 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3948 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3949 return -1; |
2967 | 3950 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3951 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3952 my = h263p_decode_umotion(s, pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3953 else |
1655 | 3954 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3955 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3956 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3957 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3958 s->mv[0][0][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3959 s->mv[0][0][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3960 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3961 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
2967 | 3962 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3963 } else { |
2967 | 3964 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3965 s->mv_type = MV_TYPE_8X8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3966 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3967 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3968 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3969 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3970 else |
1655 | 3971 mx = h263_decode_motion(s, pred_x, 1); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3972 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3973 return -1; |
2967 | 3974 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3975 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3976 my = h263p_decode_umotion(s, pred_y); |
2967 | 3977 else |
1655 | 3978 my = h263_decode_motion(s, pred_y, 1); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3979 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3980 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3981 s->mv[0][i][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3982 s->mv[0][i][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3983 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3984 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3985 mot_val[0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3986 mot_val[1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3987 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3988 } |
1655 | 3989 |
1796 | 3990 /* decode each block */ |
3991 for (i = 0; i < 6; i++) { | |
3992 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
3993 return -1; | |
3994 cbp+=cbp; | |
3995 } | |
3996 | |
1655 | 3997 if(s->obmc){ |
6481 | 3998 if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1) |
1655 | 3999 preview_obmc(s); |
4000 } | |
6481 | 4001 } else if(s->pict_type==FF_B_TYPE) { |
1655 | 4002 int mb_type; |
4003 const int stride= s->b8_stride; | |
1701 | 4004 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; |
4005 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; | |
1655 | 4006 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; |
4007 | |
2967 | 4008 //FIXME ugly |
4009 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= | |
4010 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= | |
4011 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= | |
1701 | 4012 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; |
1655 | 4013 |
4014 do{ | |
4015 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
4016 if (mb_type < 0){ | |
4017 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
4018 return -1; | |
4019 } | |
4020 | |
4021 mb_type= h263_mb_type_b_map[ mb_type ]; | |
4022 }while(!mb_type); | |
4023 | |
4024 s->mb_intra = IS_INTRA(mb_type); | |
4025 if(HAS_CBP(mb_type)){ | |
2632 | 4026 s->dsp.clear_blocks(s->block[0]); |
1655 | 4027 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); |
4028 if(s->mb_intra){ | |
4029 dquant = IS_QUANT(mb_type); | |
4030 goto intra; | |
4031 } | |
4032 | |
4033 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
4034 | |
4035 if (cbpy < 0){ | |
4036 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
4037 return -1; | |
4038 } | |
2967 | 4039 |
1655 | 4040 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
4041 cbpy ^= 0xF; | |
2967 | 4042 |
1655 | 4043 cbp = (cbpc & 3) | (cbpy << 2); |
4044 }else | |
4045 cbp=0; | |
2967 | 4046 |
1655 | 4047 assert(!s->mb_intra); |
4048 | |
4049 if(IS_QUANT(mb_type)){ | |
1656 | 4050 h263_decode_dquant(s); |
1655 | 4051 } |
4052 | |
4053 if(IS_DIRECT(mb_type)){ | |
4054 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
4055 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); | |
4056 }else{ | |
4057 s->mv_dir = 0; | |
4058 s->mv_type= MV_TYPE_16X16; | |
4059 //FIXME UMV | |
4060 | |
4061 if(USES_LIST(mb_type, 0)){ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4062 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); |
1655 | 4063 s->mv_dir = MV_DIR_FORWARD; |
4064 | |
4065 mx = h263_decode_motion(s, mx, 1); | |
4066 my = h263_decode_motion(s, my, 1); | |
2967 | 4067 |
1655 | 4068 s->mv[0][0][0] = mx; |
4069 s->mv[0][0][1] = my; | |
1701 | 4070 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4071 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4072 } |
2967 | 4073 |
1655 | 4074 if(USES_LIST(mb_type, 1)){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4075 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); |
1655 | 4076 s->mv_dir |= MV_DIR_BACKWARD; |
2967 | 4077 |
1655 | 4078 mx = h263_decode_motion(s, mx, 1); |
4079 my = h263_decode_motion(s, my, 1); | |
1701 | 4080 |
1655 | 4081 s->mv[1][0][0] = mx; |
4082 s->mv[1][0][1] = my; | |
1701 | 4083 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4084 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4085 } |
4086 } | |
2967 | 4087 |
1655 | 4088 s->current_picture.mb_type[xy]= mb_type; |
1796 | 4089 |
4090 /* decode each block */ | |
4091 for (i = 0; i < 6; i++) { | |
4092 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
4093 return -1; | |
4094 cbp+=cbp; | |
4095 } | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4096 } else { /* I-Frame */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4097 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4098 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4099 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4100 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4101 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4102 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4103 }while(cbpc == 8); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4104 |
2632 | 4105 s->dsp.clear_blocks(s->block[0]); |
4106 | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4107 dquant = cbpc & 4; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4108 s->mb_intra = 1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4109 intra: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4110 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4111 if (s->h263_aic) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4112 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4113 if(s->ac_pred){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4114 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
2967 | 4115 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4116 s->h263_aic_dir = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4117 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4118 }else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4119 s->ac_pred = 0; |
2967 | 4120 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4121 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4122 if(cbpy<0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4123 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4124 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4125 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4126 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4127 if (dquant) { |
1656 | 4128 h263_decode_dquant(s); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4129 } |
1796 | 4130 |
4131 /* decode each block */ | |
4132 for (i = 0; i < 6; i++) { | |
4133 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
4134 return -1; | |
4135 cbp+=cbp; | |
4136 } | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4137 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4138 end: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4139 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4140 /* per-MB end of slice check */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4141 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4142 int v= show_bits(&s->gb, 16); |
2967 | 4143 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4144 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4145 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4146 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4147 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4148 if(v==0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4149 return SLICE_END; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4150 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4151 |
2967 | 4152 return SLICE_OK; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4153 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4154 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4155 int ff_mpeg4_decode_mb(MpegEncContext *s, |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4156 DCTELEM block[6][64]) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4157 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4158 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4159 int16_t *mot_val; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4160 static int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4161 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
2967 | 4162 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4163 assert(s->h263_pred); |
2967 | 4164 |
6481 | 4165 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4166 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4167 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4168 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4169 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4170 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4171 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4172 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4173 s->mv_type = MV_TYPE_16X16; |
6481 | 4174 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4175 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4176 s->mcsel=1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4177 s->mv[0][0][0]= get_amv(s, 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4178 s->mv[0][0][1]= get_amv(s, 1); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4179 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4180 s->mb_skipped = 0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4181 }else{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4182 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4183 s->mcsel=0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4184 s->mv[0][0][0] = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4185 s->mv[0][0][1] = 0; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4186 s->mb_skipped = 1; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4187 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4188 goto end; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4189 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4190 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4191 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4192 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4193 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4194 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4195 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4196 }while(cbpc == 20); |
2967 | 4197 |
2632 | 4198 s->dsp.clear_blocks(s->block[0]); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4199 dquant = cbpc & 8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4200 s->mb_intra = ((cbpc & 4) != 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4201 if (s->mb_intra) goto intra; |
2967 | 4202 |
6481 | 4203 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4204 s->mcsel= get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4205 else s->mcsel= 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4206 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; |
2967 | 4207 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4208 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4209 if (dquant) { |
1652 | 4210 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4211 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4212 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
|
4213 s->interlaced_dct= get_bits1(&s->gb); |
2967 | 4214 |
0 | 4215 s->mv_dir = MV_DIR_FORWARD; |
4216 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4217 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
|
4218 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
|
4219 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4220 s->mv_type = MV_TYPE_16X16; |
753 | 4221 mx= get_amv(s, 0); |
4222 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
|
4223 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
|
4224 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
|
4225 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
2967 | 4226 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
|
4227 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4228 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
|
4229 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4230 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
|
4231 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
|
4232 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4233 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 4234 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4235 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
|
4236 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
|
4237 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4238 return -1; |
2967 | 4239 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4240 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
|
4241 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4242 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4243 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4244 s->mv[0][i][0] = mx; |
661 | 4245 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
|
4246 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4247 }else{ |
2967 | 4248 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
|
4249 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4250 s->mv_type = MV_TYPE_16X16; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4251 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4252 mx = h263_decode_motion(s, pred_x, s->f_code); |
2967 | 4253 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4254 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4255 return -1; |
2967 | 4256 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4257 my = h263_decode_motion(s, pred_y, s->f_code); |
2967 | 4258 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4259 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4260 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4261 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
|
4262 s->mv[0][0][1] = my; |
255 | 4263 } |
0 | 4264 } else { |
2967 | 4265 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 4266 s->mv_type = MV_TYPE_8X8; |
4267 for(i=0;i<4;i++) { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4268 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4269 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 4270 if (mx >= 0xffff) |
4271 return -1; | |
2967 | 4272 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4273 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 4274 if (my >= 0xffff) |
4275 return -1; | |
4276 s->mv[0][i][0] = mx; | |
4277 s->mv[0][i][1] = my; | |
4278 mot_val[0] = mx; | |
4279 mot_val[1] = my; | |
4280 } | |
4281 } | |
6481 | 4282 } else if(s->pict_type==FF_B_TYPE) { |
262 | 4283 int modb1; // first bit of modb |
4284 int modb2; // second bit of modb | |
4285 int mb_type; | |
4286 | |
4287 s->mb_intra = 0; //B-frames never contain intra blocks | |
4288 s->mcsel=0; // ... true gmc blocks | |
4289 | |
4290 if(s->mb_x==0){ | |
674 | 4291 for(i=0; i<2; i++){ |
2967 | 4292 s->last_mv[i][0][0]= |
4293 s->last_mv[i][0][1]= | |
4294 s->last_mv[i][1][0]= | |
674 | 4295 s->last_mv[i][1][1]= 0; |
4296 } | |
262 | 4297 } |
4298 | |
4299 /* if we skipped it in the future P Frame than skip it now too */ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4300 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4301 |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4302 if(s->mb_skipped){ |
262 | 4303 /* skip mb */ |
4304 for(i=0;i<6;i++) | |
4305 s->block_last_index[i] = -1; | |
4306 | |
4307 s->mv_dir = MV_DIR_FORWARD; | |
4308 s->mv_type = MV_TYPE_16X16; | |
4309 s->mv[0][0][0] = 0; | |
4310 s->mv[0][0][1] = 0; | |
4311 s->mv[1][0][0] = 0; | |
4312 s->mv[1][0][1] = 0; | |
2967 | 4313 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
|
4314 goto end; |
262 | 4315 } |
4316 | |
2967 | 4317 modb1= get_bits1(&s->gb); |
666 | 4318 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
|
4319 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 4320 cbp=0; |
4321 }else{ | |
262 | 4322 modb2= get_bits1(&s->gb); |
544 | 4323 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
|
4324 if(mb_type<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4325 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\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
|
4326 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
|
4327 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4328 mb_type= mb_type_b_map[ mb_type ]; |
666 | 4329 if(modb2) cbp= 0; |
2632 | 4330 else{ |
4331 s->dsp.clear_blocks(s->block[0]); | |
4332 cbp= get_bits(&s->gb, 6); | |
4333 } | |
666 | 4334 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4335 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 4336 if(get_bits1(&s->gb)){ |
1652 | 4337 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); |
262 | 4338 } |
4339 } | |
664 | 4340 |
4341 if(!s->progressive_sequence){ | |
4342 if(cbp) | |
4343 s->interlaced_dct= get_bits1(&s->gb); | |
4344 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4345 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
|
4346 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
|
4347 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
|
4348 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4349 if(USES_LIST(mb_type, 0)){ |
667 | 4350 s->field_select[0][0]= get_bits1(&s->gb); |
4351 s->field_select[0][1]= get_bits1(&s->gb); | |
4352 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4353 if(USES_LIST(mb_type, 1)){ |
667 | 4354 s->field_select[1][0]= get_bits1(&s->gb); |
4355 s->field_select[1][1]= get_bits1(&s->gb); | |
4356 } | |
4357 } | |
666 | 4358 } |
4359 | |
667 | 4360 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
|
4361 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 4362 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
|
4363 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4364 if(USES_LIST(mb_type, 0)){ |
666 | 4365 s->mv_dir = MV_DIR_FORWARD; |
4366 | |
4367 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
4368 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
4369 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
4370 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 4371 } |
2967 | 4372 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4373 if(USES_LIST(mb_type, 1)){ |
666 | 4374 s->mv_dir |= MV_DIR_BACKWARD; |
4375 | |
4376 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
4377 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
4378 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
4379 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
4380 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4381 }else if(!IS_DIRECT(mb_type)){ |
666 | 4382 s->mv_type= MV_TYPE_FIELD; |
667 | 4383 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4384 if(USES_LIST(mb_type, 0)){ |
666 | 4385 s->mv_dir = MV_DIR_FORWARD; |
2967 | 4386 |
666 | 4387 for(i=0; i<2; i++){ |
4388 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
4389 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
4390 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
4391 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
4392 } | |
667 | 4393 } |
2967 | 4394 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4395 if(USES_LIST(mb_type, 1)){ |
666 | 4396 s->mv_dir |= MV_DIR_BACKWARD; |
4397 | |
4398 for(i=0; i<2; i++){ | |
4399 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
4400 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
4401 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
4402 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 4403 } |
4404 } | |
4405 } | |
4406 } | |
2967 | 4407 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4408 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
|
4409 if(IS_SKIP(mb_type)) |
666 | 4410 mx=my=0; |
4411 else{ | |
4412 mx = h263_decode_motion(s, 0, 1); | |
4413 my = h263_decode_motion(s, 0, 1); | |
4414 } | |
2967 | 4415 |
262 | 4416 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
|
4417 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 4418 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4419 s->current_picture.mb_type[xy]= mb_type; |
262 | 4420 } else { /* I-Frame */ |
1482 | 4421 do{ |
4422 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
4423 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4424 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4425 return -1; |
4426 } | |
4427 }while(cbpc == 8); | |
4428 | |
262 | 4429 dquant = cbpc & 4; |
4430 s->mb_intra = 1; | |
4431 intra: | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4432 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4433 if(s->ac_pred) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4434 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4435 else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4436 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
2967 | 4437 |
544 | 4438 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1482 | 4439 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4440 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4441 return -1; |
4442 } | |
0 | 4443 cbp = (cbpc & 3) | (cbpy << 2); |
3282 | 4444 |
4445 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; | |
4446 | |
0 | 4447 if (dquant) { |
1652 | 4448 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
0 | 4449 } |
2967 | 4450 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4451 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4452 s->interlaced_dct= get_bits1(&s->gb); |
575 | 4453 |
2632 | 4454 s->dsp.clear_blocks(s->block[0]); |
575 | 4455 /* decode each block */ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4456 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4457 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4458 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4459 cbp+=cbp; |
575 | 4460 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4461 goto end; |
0 | 4462 } |
4463 | |
4464 /* decode each block */ | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4465 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4466 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4467 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4468 cbp+=cbp; |
0 | 4469 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4470 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4471 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4472 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4473 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4474 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
|
4475 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
6481 | 4476 if(s->pict_type==FF_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
|
4477 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4478 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4479 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4480 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4481 |
2967 | 4482 return SLICE_OK; |
0 | 4483 } |
4484 | |
262 | 4485 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 4486 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
4487 int code, val, sign, shift, l; |
544 | 4488 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 4489 |
4490 if (code == 0) | |
4491 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
|
4492 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
|
4493 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4494 |
21 | 4495 sign = get_bits1(&s->gb); |
262 | 4496 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
|
4497 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4498 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4499 val = (val - 1) << shift; |
0 | 4500 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
|
4501 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4502 } |
0 | 4503 if (sign) |
4504 val = -val; | |
4505 val += pred; | |
475 | 4506 |
0 | 4507 /* modulo decoding */ |
4508 if (!s->h263_long_vectors) { | |
2093 | 4509 l = INT_BIT - 5 - f_code; |
4510 val = (val<<l)>>l; | |
0 | 4511 } else { |
4512 /* horrible h263 long vector mode */ | |
4513 if (pred < -31 && val < -63) | |
4514 val += 64; | |
4515 if (pred > 32 && val > 63) | |
4516 val -= 64; | |
2967 | 4517 |
0 | 4518 } |
4519 return val; | |
4520 } | |
4521 | |
78 | 4522 /* Decodes RVLC of H.263+ UMV */ |
4523 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
4524 { | |
4525 int code = 0, sign; | |
2967 | 4526 |
78 | 4527 if (get_bits1(&s->gb)) /* Motion difference = 0 */ |
4528 return pred; | |
2967 | 4529 |
78 | 4530 code = 2 + get_bits1(&s->gb); |
2967 | 4531 |
78 | 4532 while (get_bits1(&s->gb)) |
4533 { | |
4534 code <<= 1; | |
4535 code += get_bits1(&s->gb); | |
4536 } | |
4537 sign = code & 1; | |
4538 code >>= 1; | |
2967 | 4539 |
78 | 4540 code = (sign) ? (pred - code) : (pred + code); |
4541 #ifdef DEBUG | |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4542 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code); |
78 | 4543 #endif |
2967 | 4544 return code; |
78 | 4545 |
4546 } | |
4547 | |
0 | 4548 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
4549 int n, int coded) | |
4550 { | |
4551 int code, level, i, j, last, run; | |
4552 RLTable *rl = &rl_inter; | |
1064 | 4553 const uint8_t *scan_table; |
1637 | 4554 GetBitContext gb= s->gb; |
0 | 4555 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4556 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4557 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4558 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4559 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4560 if (s->ac_pred) { |
2967 | 4561 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4562 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4563 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4564 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4565 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4566 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4567 /* DC coef */ |
1641 | 4568 if(s->codec_id == CODEC_ID_RV10){ |
8590 | 4569 #if CONFIG_RV10_DECODER |
6481 | 4570 if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) { |
0 | 4571 int component, diff; |
4572 component = (n <= 3 ? 0 : n - 4 + 1); | |
4573 level = s->last_dc[component]; | |
4574 if (s->rv10_first_dc_coded[component]) { | |
4575 diff = rv_decode_dc(s, n); | |
4576 if (diff == 0xffff) | |
4577 return -1; | |
4578 level += diff; | |
4579 level = level & 0xff; /* handle wrap round */ | |
4580 s->last_dc[component] = level; | |
4581 } else { | |
4582 s->rv10_first_dc_coded[component] = 1; | |
4583 } | |
1090 | 4584 } else { |
4585 level = get_bits(&s->gb, 8); | |
1975 | 4586 if (level == 255) |
4587 level = 128; | |
1090 | 4588 } |
2639 | 4589 #endif |
1090 | 4590 }else{ |
0 | 4591 level = get_bits(&s->gb, 8); |
1089 | 4592 if((level&0x7F) == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4593 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
7831 | 4594 if(s->error_recognition >= FF_ER_COMPLIANT) |
1752 | 4595 return -1; |
1089 | 4596 } |
0 | 4597 if (level == 255) |
4598 level = 128; | |
4599 } | |
4600 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4601 i = 1; |
0 | 4602 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4603 i = 0; |
0 | 4604 } |
4605 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4606 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4607 goto not_coded; |
0 | 4608 s->block_last_index[n] = i - 1; |
4609 return 0; | |
4610 } | |
1637 | 4611 retry: |
0 | 4612 for(;;) { |
544 | 4613 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
|
4614 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4615 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 4616 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4617 } |
0 | 4618 if (code == rl->n) { |
4619 /* escape */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4620 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4621 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
|
4622 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4623 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
|
4624 if(is11){ |
1356 | 4625 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
|
4626 } else { |
1356 | 4627 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
|
4628 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4629 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4630 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4631 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
|
4632 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
|
4633 if(level == -128){ |
1641 | 4634 if (s->codec_id == CODEC_ID_RV10) { |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4635 /* XXX: should patch encoder too */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4636 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
|
4637 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4638 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
|
4639 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
|
4640 } |
1089 | 4641 } |
0 | 4642 } |
4643 } else { | |
4644 run = rl->table_run[code]; | |
4645 level = rl->table_level[code]; | |
4646 last = code >= rl->last; | |
21 | 4647 if (get_bits1(&s->gb)) |
0 | 4648 level = -level; |
4649 } | |
4650 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4651 if (i >= 64){ |
1637 | 4652 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ |
5129 | 4653 //Looks like a hack but no, it's the way it is supposed to work ... |
1637 | 4654 rl = &rl_intra_aic; |
4655 i = 0; | |
4656 s->gb= gb; | |
8288 | 4657 s->dsp.clear_block(block); |
1637 | 4658 goto retry; |
4659 } | |
2406 | 4660 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); |
0 | 4661 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4662 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4663 j = scan_table[i]; |
0 | 4664 block[j] = level; |
4665 if (last) | |
4666 break; | |
4667 i++; | |
4668 } | |
2967 | 4669 not_coded: |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4670 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4671 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
4672 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4673 } |
0 | 4674 s->block_last_index[n] = i; |
4675 return 0; | |
4676 } | |
4677 | |
1034 | 4678 /** |
4679 * decodes the dc value. | |
4680 * @param n block index (0-3 are luma, 4-5 are chroma) | |
4681 * @param dir_ptr the prediction direction will be stored here | |
4682 * @return the quantized dc | |
4683 */ | |
453 | 4684 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 4685 { |
2003 | 4686 int level, code; |
0 | 4687 |
2967 | 4688 if (n < 4) |
544 | 4689 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
2967 | 4690 else |
544 | 4691 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 4692 if (code < 0 || code > 9 /* && s->nbit<9 */){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4693 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
0 | 4694 return -1; |
453 | 4695 } |
0 | 4696 if (code == 0) { |
4697 level = 0; | |
4698 } 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
|
4699 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
|
4700 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
|
4701 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
|
4702 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
|
4703 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
|
4704 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
|
4705 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
|
4706 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
|
4707 } |
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
|
4708 }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
|
4709 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
|
4710 } |
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
|
4711 |
453 | 4712 if (code > 8){ |
4713 if(get_bits1(&s->gb)==0){ /* marker */ | |
7831 | 4714 if(s->error_recognition>=2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4715 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n"); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4716 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4717 } |
453 | 4718 } |
4719 } | |
0 | 4720 } |
2003 | 4721 |
4722 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); | |
0 | 4723 } |
4724 | |
453 | 4725 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4726 * decodes a block. |
6524 | 4727 * @return <0 if an error occurred |
453 | 4728 */ |
4729 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 4730 int n, int coded, int intra, int rvlc) |
0 | 4731 { |
549 | 4732 int level, i, last, run; |
6211
ed359f380aa7
Revert r11689 and r11690 (uninitalized warning fix) as its theoretically
michael
parents:
6209
diff
changeset
|
4733 int dc_pred_dir; |
575 | 4734 RLTable * rl; |
4735 RL_VLC_ELEM * rl_vlc; | |
1064 | 4736 const uint8_t * scan_table; |
549 | 4737 int qmul, qadd; |
0 | 4738 |
1132 | 4739 //Note intra & rvlc should be optimized away if this is inlined |
2967 | 4740 |
575 | 4741 if(intra) { |
3282 | 4742 if(s->use_intra_dc_vlc){ |
2979 | 4743 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4744 if(s->partitioned_frame){ |
453 | 4745 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
|
4746 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
|
4747 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
|
4748 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 4749 }else{ |
4750 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
4751 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4752 return -1; |
453 | 4753 } |
0 | 4754 block[0] = level; |
549 | 4755 i = 0; |
1520 | 4756 }else{ |
4757 i = -1; | |
3182 | 4758 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0); |
2967 | 4759 } |
6201 | 4760 if (!coded) |
4761 goto not_coded; | |
4762 | |
4763 if(rvlc){ | |
4764 rl = &rvlc_rl_intra; | |
4765 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
4766 }else{ | |
4767 rl = &rl_intra; | |
4768 rl_vlc = rl_intra.rl_vlc[0]; | |
4769 } | |
4770 if (s->ac_pred) { | |
4771 if (dc_pred_dir == 0) | |
4772 scan_table = s->intra_v_scantable.permutated; /* left */ | |
4773 else | |
4774 scan_table = s->intra_h_scantable.permutated; /* top */ | |
4775 } else { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4776 scan_table = s->intra_scantable.permutated; |
6201 | 4777 } |
4778 qmul=1; | |
4779 qadd=0; | |
0 | 4780 } else { |
549 | 4781 i = -1; |
0 | 4782 if (!coded) { |
549 | 4783 s->block_last_index[n] = i; |
0 | 4784 return 0; |
4785 } | |
1132 | 4786 if(rvlc) rl = &rvlc_rl_inter; |
4787 else rl = &rl_inter; | |
2967 | 4788 |
718 | 4789 scan_table = s->intra_scantable.permutated; |
661 | 4790 |
591 | 4791 if(s->mpeg_quant){ |
4792 qmul=1; | |
4793 qadd=0; | |
2967 | 4794 if(rvlc){ |
4795 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
1132 | 4796 }else{ |
2967 | 4797 rl_vlc = rl_inter.rl_vlc[0]; |
1132 | 4798 } |
591 | 4799 }else{ |
4800 qmul = s->qscale << 1; | |
4801 qadd = (s->qscale - 1) | 1; | |
2967 | 4802 if(rvlc){ |
4803 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
1132 | 4804 }else{ |
2967 | 4805 rl_vlc = rl_inter.rl_vlc[s->qscale]; |
1132 | 4806 } |
591 | 4807 } |
0 | 4808 } |
549 | 4809 { |
4810 OPEN_READER(re, &s->gb); | |
0 | 4811 for(;;) { |
549 | 4812 UPDATE_CACHE(re, &s->gb); |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4813 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
549 | 4814 if (level==0) { |
2967 | 4815 /* escape */ |
1132 | 4816 if(rvlc){ |
4817 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4818 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); |
1132 | 4819 return -1; |
4820 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4821 |
1132 | 4822 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
4823 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4824 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
4825 UPDATE_CACHE(re, &s->gb); | |
2967 | 4826 |
1132 | 4827 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4828 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); |
1132 | 4829 return -1; |
4830 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4831 |
1132 | 4832 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); |
2967 | 4833 |
1132 | 4834 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4835 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); |
1132 | 4836 return -1; |
4837 }; SKIP_CACHE(re, &s->gb, 5); | |
4838 | |
4839 level= level * qmul + qadd; | |
4840 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
4841 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
4842 | |
4843 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
|
4844 if(last) i+=192; |
1132 | 4845 }else{ |
549 | 4846 int cache; |
4847 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
|
4848 |
2967 | 4849 if(IS_3IV1) |
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
|
4850 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
|
4851 |
549 | 4852 if (cache&0x80000000) { |
4853 if (cache&0x40000000) { | |
0 | 4854 /* third escape */ |
549 | 4855 SKIP_CACHE(re, &s->gb, 2); |
4856 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4857 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4858 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
4859 UPDATE_CACHE(re, &s->gb); | |
4860 | |
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
|
4861 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
|
4862 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
|
4863 }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
|
4864 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4865 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n"); |
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
|
4866 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
|
4867 }; 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
|
4868 |
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
|
4869 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
|
4870 |
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
|
4871 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4872 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n"); |
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
|
4873 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
|
4874 }; 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
|
4875 |
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
|
4876 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
|
4877 } |
2967 | 4878 |
1525
39efe24058ad
dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents:
1522
diff
changeset
|
4879 #if 0 |
7831 | 4880 if(s->error_recognition >= FF_ER_COMPLIANT){ |
4001 | 4881 const int abs_level= FFABS(level); |
1525
39efe24058ad
dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents:
1522
diff
changeset
|
4882 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
498 | 4883 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 4884 if(abs_level <= rl->max_level[last][run]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4885 av_log(s->avctx, AV_LOG_ERROR, "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
|
4886 return -1; |
453 | 4887 } |
7831 | 4888 if(s->error_recognition > FF_ER_COMPLIANT){ |
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
|
4889 if(abs_level <= rl->max_level[last][run]*2){ |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4890 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); |
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
|
4891 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
|
4892 } |
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
|
4893 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4894 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); |
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
|
4895 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
|
4896 } |
453 | 4897 } |
4898 } | |
4899 } | |
4900 #endif | |
2979 | 4901 if (level>0) level= level * qmul + qadd; |
549 | 4902 else level= level * qmul - qadd; |
4903 | |
2080 | 4904 if((unsigned)(level + 2048) > 4095){ |
7831 | 4905 if(s->error_recognition > FF_ER_COMPLIANT){ |
2080 | 4906 if(level > 2560 || level<-2560){ |
4907 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | |
4908 return -1; | |
4909 } | |
4910 } | |
4911 level= level<0 ? -2048 : 2047; | |
4912 } | |
4913 | |
549 | 4914 i+= run + 1; |
4915 if(last) i+=192; | |
0 | 4916 } else { |
4917 /* second escape */ | |
549 | 4918 #if MIN_CACHE_BITS < 20 |
4919 LAST_SKIP_BITS(re, &s->gb, 2); | |
4920 UPDATE_CACHE(re, &s->gb); | |
4921 #else | |
4922 SKIP_BITS(re, &s->gb, 2); | |
4923 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4924 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4925 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing |
4926 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4927 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4928 } |
4929 } else { | |
4930 /* first escape */ | |
549 | 4931 #if MIN_CACHE_BITS < 19 |
4932 LAST_SKIP_BITS(re, &s->gb, 1); | |
4933 UPDATE_CACHE(re, &s->gb); | |
4934 #else | |
4935 SKIP_BITS(re, &s->gb, 1); | |
4936 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4937 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4938 i+= run; |
4939 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4940 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4941 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4942 } |
1132 | 4943 } |
0 | 4944 } else { |
549 | 4945 i+= run; |
4946 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4947 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4948 } |
549 | 4949 if (i > 62){ |
4950 i-= 192; | |
4951 if(i&(~63)){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4952 av_log(s->avctx, AV_LOG_ERROR, "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
|
4953 return -1; |
549 | 4954 } |
4955 | |
4956 block[scan_table[i]] = level; | |
0 | 4957 break; |
549 | 4958 } |
4959 | |
4960 block[scan_table[i]] = level; | |
0 | 4961 } |
549 | 4962 CLOSE_READER(re, &s->gb); |
4963 } | |
0 | 4964 not_coded: |
1520 | 4965 if (intra) { |
3282 | 4966 if(!s->use_intra_dc_vlc){ |
2003 | 4967 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); |
2967 | 4968 |
3181 | 4969 i -= i>>31; //if(i == -1) i=0; |
1520 | 4970 } |
4971 | |
0 | 4972 mpeg4_pred_ac(s, block, n, dc_pred_dir); |
4973 if (s->ac_pred) { | |
549 | 4974 i = 63; /* XXX: not optimal */ |
0 | 4975 } |
4976 } | |
549 | 4977 s->block_last_index[n] = i; |
0 | 4978 return 0; |
4979 } | |
4980 | |
4981 /* most is hardcoded. should extend to handle all h263 streams */ | |
4982 int h263_decode_picture_header(MpegEncContext *s) | |
4983 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4984 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4985 uint32_t startcode; |
2967 | 4986 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4987 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4988 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4989 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4990 |
1393 | 4991 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
|
4992 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
2967 | 4993 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4994 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4995 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4996 } |
2967 | 4997 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4998 if (startcode != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4999 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 5000 return -1; |
355 | 5001 } |
5002 /* temporal reference */ | |
1865 | 5003 i = get_bits(&s->gb, 8); /* picture timestamp */ |
5004 if( (s->picture_number&~0xFF)+i < s->picture_number) | |
5005 i+= 256; | |
2886 | 5006 s->current_picture_ptr->pts= |
1865 | 5007 s->picture_number= (s->picture_number&~0xFF) + i; |
355 | 5008 |
2967 | 5009 /* PTYPE starts here */ |
355 | 5010 if (get_bits1(&s->gb) != 1) { |
5011 /* marker */ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5012 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
355 | 5013 return -1; |
5014 } | |
5015 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5016 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 5017 return -1; /* h263 id */ |
5018 } | |
5019 skip_bits1(&s->gb); /* split screen off */ | |
5020 skip_bits1(&s->gb); /* camera off */ | |
5021 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 5022 |
5023 format = get_bits(&s->gb, 3); | |
355 | 5024 /* |
5025 0 forbidden | |
5026 1 sub-QCIF | |
5027 10 QCIF | |
2979 | 5028 7 extended PTYPE (PLUSPTYPE) |
355 | 5029 */ |
0 | 5030 |
161 | 5031 if (format != 7 && format != 6) { |
0 | 5032 s->h263_plus = 0; |
5033 /* H.263v1 */ | |
5034 width = h263_format[format][0]; | |
5035 height = h263_format[format][1]; | |
5036 if (!width) | |
5037 return -1; | |
2967 | 5038 |
6481 | 5039 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); |
0 | 5040 |
2967 | 5041 s->h263_long_vectors = get_bits1(&s->gb); |
0 | 5042 |
355 | 5043 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5044 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); |
2979 | 5045 return -1; /* SAC: off */ |
355 | 5046 } |
1633 | 5047 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5048 s->unrestricted_mv = s->h263_long_vectors || s->obmc; | |
2967 | 5049 |
355 | 5050 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5051 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n"); |
2979 | 5052 return -1; /* not PB frame */ |
355 | 5053 } |
1644 | 5054 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 5055 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
1393 | 5056 |
5057 s->width = width; | |
5058 s->height = height; | |
1865 | 5059 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
2637 | 5060 s->avctx->time_base= (AVRational){1001, 30000}; |
0 | 5061 } else { |
161 | 5062 int ufep; |
2967 | 5063 |
0 | 5064 /* H.263v2 */ |
161 | 5065 s->h263_plus = 1; |
5066 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 5067 |
2967 | 5068 /* ufep other than 0 and 1 are reserved */ |
161 | 5069 if (ufep == 1) { |
2967 | 5070 /* OPPTYPE */ |
161 | 5071 format = get_bits(&s->gb, 3); |
4652 | 5072 dprintf(s->avctx, "ufep=1, format: %d\n", format); |
1872 | 5073 s->custom_pcf= get_bits1(&s->gb); |
5513 | 5074 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ |
1644 | 5075 if (get_bits1(&s->gb) != 0) { |
5076 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); | |
5077 } | |
1633 | 5078 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5079 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ | |
1644 | 5080 s->loop_filter= get_bits1(&s->gb); |
5081 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; | |
2967 | 5082 |
1661 | 5083 s->h263_slice_structured= get_bits1(&s->gb); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5084 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5085 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5086 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5087 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5088 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5089 } |
1637 | 5090 s->alt_inter_vlc= get_bits1(&s->gb); |
1639 | 5091 s->modified_quant= get_bits1(&s->gb); |
1644 | 5092 if(s->modified_quant) |
5093 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 5094 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5095 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 5096 |
161 | 5097 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 5098 } else if (ufep != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5099 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); |
0 | 5100 return -1; |
355 | 5101 } |
2967 | 5102 |
78 | 5103 /* MPPTYPE */ |
1655 | 5104 s->pict_type = get_bits(&s->gb, 3); |
5105 switch(s->pict_type){ | |
6481 | 5106 case 0: s->pict_type= FF_I_TYPE;break; |
5107 case 1: s->pict_type= FF_P_TYPE;break; | |
5108 case 3: s->pict_type= FF_B_TYPE;break; | |
5109 case 7: s->pict_type= FF_I_TYPE;break; //ZYGO | |
1655 | 5110 default: |
0 | 5111 return -1; |
1655 | 5112 } |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5113 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5114 s->no_rounding = get_bits1(&s->gb); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5115 skip_bits(&s->gb, 4); |
2967 | 5116 |
78 | 5117 /* Get the picture dimensions */ |
161 | 5118 if (ufep) { |
5119 if (format == 6) { | |
5120 /* Custom Picture Format (CPFMT) */ | |
355 | 5121 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4652 | 5122 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info); |
355 | 5123 /* aspect ratios: |
5124 0 - forbidden | |
5125 1 - 1:1 | |
5126 2 - 12:11 (CIF 4:3) | |
5127 3 - 10:11 (525-type 4:3) | |
5128 4 - 16:11 (CIF 16:9) | |
5129 5 - 40:33 (525-type 16:9) | |
5130 6-14 - reserved | |
5131 */ | |
161 | 5132 width = (get_bits(&s->gb, 9) + 1) * 4; |
5133 skip_bits1(&s->gb); | |
5134 height = get_bits(&s->gb, 9) * 4; | |
4652 | 5135 dprintf(s->avctx, "\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
|
5136 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 5137 /* aspected dimensions */ |
1548 | 5138 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); |
5139 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); | |
887 | 5140 }else{ |
1548 | 5141 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
355 | 5142 } |
5143 } else { | |
161 | 5144 width = h263_format[format][0]; |
5145 height = h263_format[format][1]; | |
1865 | 5146 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
161 | 5147 } |
5148 if ((width == 0) || (height == 0)) | |
5149 return -1; | |
5150 s->width = width; | |
5151 s->height = height; | |
1872 | 5152 |
5153 if(s->custom_pcf){ | |
5154 int gcd; | |
2637 | 5155 s->avctx->time_base.den= 1800000; |
5156 s->avctx->time_base.num= 1000 + get_bits1(&s->gb); | |
5157 s->avctx->time_base.num*= get_bits(&s->gb, 7); | |
5158 if(s->avctx->time_base.num == 0){ | |
1872 | 5159 av_log(s, AV_LOG_ERROR, "zero framerate\n"); |
5160 return -1; | |
5161 } | |
8611 | 5162 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); |
2637 | 5163 s->avctx->time_base.den /= gcd; |
5164 s->avctx->time_base.num /= gcd; | |
5165 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num); | |
1872 | 5166 }else{ |
2637 | 5167 s->avctx->time_base= (AVRational){1001, 30000}; |
1872 | 5168 } |
5169 } | |
2967 | 5170 |
1872 | 5171 if(s->custom_pcf){ |
5172 skip_bits(&s->gb, 2); //extended Temporal reference | |
5173 } | |
5174 | |
5175 if (ufep) { | |
1089 | 5176 if (s->umvplus) { |
5177 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
2967 | 5178 skip_bits1(&s->gb); |
161 | 5179 } |
1661 | 5180 if(s->h263_slice_structured){ |
5181 if (get_bits1(&s->gb) != 0) { | |
5182 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); | |
5183 } | |
5184 if (get_bits1(&s->gb) != 0) { | |
5185 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); | |
5186 } | |
5187 } | |
78 | 5188 } |
2967 | 5189 |
0 | 5190 s->qscale = get_bits(&s->gb, 5); |
5191 } | |
1670 | 5192 |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5193 s->mb_width = (s->width + 15) / 16; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5194 s->mb_height = (s->height + 15) / 16; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5195 s->mb_num = s->mb_width * s->mb_height; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5196 |
0 | 5197 /* PEI */ |
21 | 5198 while (get_bits1(&s->gb) != 0) { |
5199 skip_bits(&s->gb, 8); | |
0 | 5200 } |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5201 |
1670 | 5202 if(s->h263_slice_structured){ |
5203 if (get_bits1(&s->gb) != 1) { | |
5204 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); | |
5205 return -1; | |
5206 } | |
5207 | |
5208 ff_h263_decode_mba(s); | |
5209 | |
5210 if (get_bits1(&s->gb) != 1) { | |
5211 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
5212 return -1; | |
5213 } | |
5214 } | |
0 | 5215 s->f_code = 1; |
2967 | 5216 |
498 | 5217 if(s->h263_aic){ |
2967 | 5218 s->y_dc_scale_table= |
1639 | 5219 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 5220 }else{ |
5221 s->y_dc_scale_table= | |
5222 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
5223 } | |
5224 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5225 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
5403 | 5226 show_pict_info(s); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5227 } |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5228 #if 1 |
8612 | 5229 if (s->pict_type == FF_I_TYPE && s->codec_tag == AV_RL32("ZYGO")){ |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5230 int i,j; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5231 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5232 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5233 for(i=0; i<13; i++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5234 for(j=0; j<3; j++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5235 int v= get_bits(&s->gb, 8); |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5236 v |= get_sbits(&s->gb, 8)<<8; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5237 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5238 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5239 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5240 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5241 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5242 } |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5243 #endif |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5244 |
0 | 5245 return 0; |
5246 } | |
5247 | |
1914 | 5248 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb) |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5249 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5250 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5251 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5252 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5253 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5254 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
|
5255 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
|
5256 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5257 int virtual_ref[2][2]; |
753 | 5258 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5259 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5260 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5261 int h= s->height; |
753 | 5262 int min_ab; |
5263 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5264 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
|
5265 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5266 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5267 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5268 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5269 if(length){ |
1914 | 5270 x= get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5271 } |
1914 | 5272 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */ |
2967 | 5273 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5274 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5275 if(length){ |
1914 | 5276 y=get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5277 } |
1914 | 5278 skip_bits1(gb); /* marker bit */ |
255 | 5279 //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
|
5280 d[i][0]= x; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5281 d[i][1]= y; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5282 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5283 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5284 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5285 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
|
5286 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5287 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5288 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5289 // Note, the 4th point isn't used for GMC |
262 | 5290 if(s->divx_version==500 && s->divx_build==413){ |
5291 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
5292 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
5293 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
5294 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
5295 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
5296 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
5297 } else { | |
5298 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
5299 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
5300 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
5301 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
5302 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
5303 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
5304 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5305 /* 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
|
5306 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ |
2967 | 5307 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5308 // 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
|
5309 // 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
|
5310 // 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
|
5311 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form |
2967 | 5312 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 5313 + 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); |
2967 | 5314 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 5315 + 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); |
2967 | 5316 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 5317 + 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); |
2967 | 5318 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 5319 + 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); |
2967 | 5320 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5321 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5322 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5323 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5324 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5325 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5326 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5327 s->sprite_offset[1][1]= 0; |
753 | 5328 s->sprite_delta[0][0]= a; |
5329 s->sprite_delta[0][1]= 0; | |
5330 s->sprite_delta[1][0]= 0; | |
5331 s->sprite_delta[1][1]= a; | |
5332 s->sprite_shift[0]= 0; | |
5333 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5334 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5335 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5336 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
|
5337 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
|
5338 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
|
5339 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 5340 s->sprite_delta[0][0]= a; |
5341 s->sprite_delta[0][1]= 0; | |
5342 s->sprite_delta[1][0]= 0; | |
5343 s->sprite_delta[1][1]= a; | |
5344 s->sprite_shift[0]= 0; | |
5345 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5346 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5347 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5348 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 5349 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
5350 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
5351 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5352 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 5353 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
5354 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
5355 + (1<<(alpha+rho-1)); | |
5356 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
5357 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
2967 | 5358 +2*w2*r*sprite_ref[0][0] |
5359 - 16*w2 | |
753 | 5360 + (1<<(alpha+rho+1))); |
2967 | 5361 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) |
753 | 5362 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) |
2967 | 5363 +2*w2*r*sprite_ref[0][1] |
753 | 5364 - 16*w2 |
5365 + (1<<(alpha+rho+1))); | |
5366 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
5367 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
5368 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
5369 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
2967 | 5370 |
753 | 5371 s->sprite_shift[0]= alpha+rho; |
5372 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
|
5373 break; |
753 | 5374 case 3: |
847 | 5375 min_ab= FFMIN(alpha, beta); |
753 | 5376 w3= w2>>min_ab; |
5377 h3= h2>>min_ab; | |
5378 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
5379 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
5380 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
5381 + (1<<(alpha+beta+rho-min_ab-1)); | |
5382 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
5383 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
5384 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
5385 + (1<<(alpha+beta+rho-min_ab-1)); | |
5386 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
5387 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
5388 + 2*w2*h3*r*sprite_ref[0][0] | |
5389 - 16*w2*h3 | |
5390 + (1<<(alpha+beta+rho-min_ab+1)); | |
5391 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
5392 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
5393 + 2*w2*h3*r*sprite_ref[0][1] | |
5394 - 16*w2*h3 | |
5395 + (1<<(alpha+beta+rho-min_ab+1)); | |
5396 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
5397 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
5398 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
5399 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
2967 | 5400 |
753 | 5401 s->sprite_shift[0]= alpha + beta + rho - min_ab; |
5402 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
|
5403 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5404 } |
2967 | 5405 /* try to simplify the situation */ |
753 | 5406 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
5407 && s->sprite_delta[0][1] == 0 | |
5408 && s->sprite_delta[1][0] == 0 | |
5409 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 5410 { |
753 | 5411 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
5412 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
5413 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
5414 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
5415 s->sprite_delta[0][0]= a; | |
5416 s->sprite_delta[0][1]= 0; | |
5417 s->sprite_delta[1][0]= 0; | |
5418 s->sprite_delta[1][1]= a; | |
5419 s->sprite_shift[0]= 0; | |
5420 s->sprite_shift[1]= 0; | |
255 | 5421 s->real_sprite_warping_points=1; |
5422 } | |
753 | 5423 else{ |
5424 int shift_y= 16 - s->sprite_shift[0]; | |
5425 int shift_c= 16 - s->sprite_shift[1]; | |
5426 //printf("shifts %d %d\n", shift_y, shift_c); | |
5427 for(i=0; i<2; i++){ | |
5428 s->sprite_offset[0][i]<<= shift_y; | |
5429 s->sprite_offset[1][i]<<= shift_c; | |
5430 s->sprite_delta[0][i]<<= shift_y; | |
5431 s->sprite_delta[1][i]<<= shift_y; | |
5432 s->sprite_shift[i]= 16; | |
5433 } | |
255 | 5434 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 5435 } |
5436 #if 0 | |
5437 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", | |
5438 vop_ref[0][0], vop_ref[0][1], | |
5439 vop_ref[1][0], vop_ref[1][1], | |
5440 vop_ref[2][0], vop_ref[2][1], | |
2967 | 5441 sprite_ref[0][0], sprite_ref[0][1], |
5442 sprite_ref[1][0], sprite_ref[1][1], | |
5443 sprite_ref[2][0], sprite_ref[2][1], | |
5444 virtual_ref[0][0], virtual_ref[0][1], | |
753 | 5445 virtual_ref[1][0], virtual_ref[1][1] |
5446 ); | |
2967 | 5447 |
753 | 5448 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", |
5449 s->sprite_offset[0][0], s->sprite_offset[0][1], | |
5450 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
5451 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
5452 s->sprite_shift[0] | |
5453 ); | |
5454 #endif | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5455 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5456 |
942 | 5457 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
5458 int hours, minutes, seconds; | |
5459 | |
5460 hours= get_bits(gb, 5); | |
5461 minutes= get_bits(gb, 6); | |
5462 skip_bits1(gb); | |
5463 seconds= get_bits(gb, 6); | |
5464 | |
5465 s->time_base= seconds + 60*(minutes + 60*hours); | |
5466 | |
5467 skip_bits1(gb); | |
5468 skip_bits1(gb); | |
2967 | 5469 |
942 | 5470 return 0; |
5471 } | |
5472 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5473 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
|
5474 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
|
5475 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5476 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5477 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
|
5478 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
|
5479 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
|
5480 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
|
5481 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
|
5482 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5483 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5484 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5485 //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
|
5486 s->aspect_ratio_info= get_bits(gb, 4); |
2967 | 5487 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
1548 | 5488 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width |
5489 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height | |
887 | 5490 }else{ |
1548 | 5491 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5492 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5493 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5494 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
|
5495 int chroma_format= get_bits(gb, 2); |
8690 | 5496 if(chroma_format!=CHROMA_420){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5497 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5498 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5499 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
|
5500 if(get_bits1(gb)){ /* vbv parameters */ |
2979 | 5501 get_bits(gb, 15); /* first_half_bitrate */ |
5502 skip_bits1(gb); /* marker */ | |
5503 get_bits(gb, 15); /* latter_half_bitrate */ | |
5504 skip_bits1(gb); /* marker */ | |
5505 get_bits(gb, 15); /* first_half_vbv_buffer_size */ | |
5506 skip_bits1(gb); /* marker */ | |
5507 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ | |
5508 get_bits(gb, 11); /* first_half_vbv_occupancy */ | |
5509 skip_bits1(gb); /* marker */ | |
5510 get_bits(gb, 15); /* latter_half_vbv_occupancy */ | |
5511 skip_bits1(gb); /* marker */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5512 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5513 }else{ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5514 // set low delay flag only once the smartest? low delay detection won't be overriden |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5515 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5516 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5517 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5518 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5519 s->shape = get_bits(gb, 2); /* vol shape */ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5520 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5521 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5522 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5523 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
|
5524 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5525 |
1411 | 5526 check_marker(gb, "before time_increment_resolution"); |
2967 | 5527 |
2637 | 5528 s->avctx->time_base.den = get_bits(gb, 16); |
2812 | 5529 if(!s->avctx->time_base.den){ |
5530 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n"); | |
5531 return -1; | |
5532 } | |
2967 | 5533 |
2637 | 5534 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5535 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
|
5536 s->time_increment_bits = 1; |
2967 | 5537 |
1411 | 5538 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
|
5539 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5540 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ |
2637 | 5541 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits); |
5542 }else | |
5543 s->avctx->time_base.num = 1; | |
5544 | |
2034 | 5545 s->t_frame=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5546 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5547 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
|
5548 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5549 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5550 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5551 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5552 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5553 skip_bits1(gb); /* marker */ |
8612 | 5554 if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5555 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5556 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5557 // 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
|
5558 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5559 } |
2967 | 5560 |
5561 s->progressive_sequence= | |
1659 | 5562 s->progressive_frame= get_bits1(gb)^1; |
3192 | 5563 s->interlaced_dct=0; |
2967 | 5564 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
1644 | 5565 av_log(s->avctx, AV_LOG_INFO, "MPEG4 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
|
5566 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5567 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
|
5568 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5569 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
|
5570 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5571 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5572 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
|
5573 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
|
5574 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
|
5575 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5576 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
|
5577 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5578 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
|
5579 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5580 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
|
5581 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5582 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5583 s->num_sprite_warping_points= get_bits(gb, 6); |
4930
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5584 if(s->num_sprite_warping_points > 3){ |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5585 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points); |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5586 s->num_sprite_warping_points= 0; |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5587 return -1; |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5588 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5589 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
|
5590 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
|
5591 if(s->vol_sprite_usage==STATIC_SPRITE) |
2967 | 5592 s->low_latency_sprite= get_bits1(gb); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5593 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5594 // FIXME sadct disable bit if verid!=1 && shape not rect |
2967 | 5595 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5596 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
|
5597 s->quant_precision = get_bits(gb, 4); /* quant_precision */ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5598 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */ |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5599 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5600 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5601 s->quant_precision = 5; |
0 | 5602 } |
2967 | 5603 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5604 // 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
|
5605 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5606 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 5607 int i, v; |
2967 | 5608 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5609 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5610 for(i=0; i<64; i++){ |
1092 | 5611 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
|
5612 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
|
5613 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5614 s->chroma_intra_matrix[j]= v; |
2967 | 5615 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5616 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
|
5617 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5618 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
|
5619 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5620 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5621 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5622 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5623 int last=0; |
2979 | 5624 for(i=0; i<64; i++){ |
1057 | 5625 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5626 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5627 if(v==0) break; |
2967 | 5628 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5629 last= v; |
1092 | 5630 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
|
5631 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5632 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
|
5633 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5634 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5635 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5636 for(; i<64; i++){ |
2979 | 5637 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
1411 | 5638 s->intra_matrix[j]= last; |
5639 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
|
5640 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5641 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5642 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5643 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5644 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5645 int last=0; |
2979 | 5646 for(i=0; i<64; i++){ |
1057 | 5647 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5648 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5649 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5650 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5651 last= v; |
1092 | 5652 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
|
5653 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5654 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
|
5655 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5656 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5657 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5658 for(; i<64; i++){ |
2979 | 5659 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
|
5660 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5661 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
|
5662 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5663 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5664 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5665 // 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
|
5666 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5667 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5668 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5669 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
|
5670 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5671 |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5672 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5673 int pos= get_bits_count(gb); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5674 int estimation_method= get_bits(gb, 2); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5675 if(estimation_method<2){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5676 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5677 s->cplx_estimation_trash_i += 8*get_bits1(gb); //opaque |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5678 s->cplx_estimation_trash_i += 8*get_bits1(gb); //transparent |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5679 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_cae |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5680 s->cplx_estimation_trash_i += 8*get_bits1(gb); //inter_cae |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5681 s->cplx_estimation_trash_i += 8*get_bits1(gb); //no_update |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5682 s->cplx_estimation_trash_i += 8*get_bits1(gb); //upampling |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5683 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5684 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5685 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_blocks |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5686 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter_blocks |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5687 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter4v_blocks |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5688 s->cplx_estimation_trash_i += 8*get_bits1(gb); //not coded blocks |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5689 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5690 if(!check_marker(gb, "in complexity estimation part 1")){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5691 skip_bits_long(gb, pos - get_bits_count(gb)); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5692 goto no_cplx_est; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5693 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5694 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5695 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_coeffs |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5696 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_lines |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5697 s->cplx_estimation_trash_i += 8*get_bits1(gb); //vlc_syms |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5698 s->cplx_estimation_trash_i += 4*get_bits1(gb); //vlc_bits |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5699 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5700 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5701 s->cplx_estimation_trash_p += 8*get_bits1(gb); //apm |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5702 s->cplx_estimation_trash_p += 8*get_bits1(gb); //npm |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5703 s->cplx_estimation_trash_b += 8*get_bits1(gb); //interpolate_mc_q |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5704 s->cplx_estimation_trash_p += 8*get_bits1(gb); //forwback_mc_q |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5705 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel2 |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5706 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel4 |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5707 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5708 if(!check_marker(gb, "in complexity estimation part 2")){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5709 skip_bits_long(gb, pos - get_bits_count(gb)); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5710 goto no_cplx_est; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5711 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5712 if(estimation_method==1){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5713 s->cplx_estimation_trash_i += 8*get_bits1(gb); //sadct |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5714 s->cplx_estimation_trash_p += 8*get_bits1(gb); //qpel |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5715 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5716 }else |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5717 av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5718 }else{ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5719 no_cplx_est: |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5720 s->cplx_estimation_trash_i= |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5721 s->cplx_estimation_trash_p= |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5722 s->cplx_estimation_trash_b= 0; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5723 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5724 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5725 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
|
5726 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5727 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
|
5728 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5729 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5730 } |
2967 | 5731 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5732 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5733 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
|
5734 if(s->new_pred){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5735 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5736 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
|
5737 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
|
5738 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5739 s->reduced_res_vop= get_bits1(gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5740 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5741 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5742 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5743 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5744 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5745 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5746 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5747 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5748 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5749 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5750 GetBitContext bak= *gb; |
751 | 5751 int ref_layer_id; |
5752 int ref_layer_sampling_dir; | |
5753 int h_sampling_factor_n; | |
5754 int h_sampling_factor_m; | |
5755 int v_sampling_factor_n; | |
5756 int v_sampling_factor_m; | |
2967 | 5757 |
751 | 5758 s->hierachy_type= get_bits1(gb); |
5759 ref_layer_id= get_bits(gb, 4); | |
5760 ref_layer_sampling_dir= get_bits1(gb); | |
5761 h_sampling_factor_n= get_bits(gb, 5); | |
5762 h_sampling_factor_m= get_bits(gb, 5); | |
5763 v_sampling_factor_n= get_bits(gb, 5); | |
5764 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
|
5765 s->enhancement_type= get_bits1(gb); |
2967 | 5766 |
5767 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5768 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ |
2967 | 5769 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5770 // 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
|
5771 s->scalability=0; |
2967 | 5772 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5773 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5774 }else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5775 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); |
2967 | 5776 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5777 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5778 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5779 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5780 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5781 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5782 |
1034 | 5783 /** |
5784 * decodes the user data stuff in the header. | |
6918 | 5785 * Also initializes divx/xvid/lavc_version/build. |
1034 | 5786 */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5787 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
|
5788 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5789 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5790 int e; |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5791 int ver = 0, build = 0, ver2 = 0, ver3 = 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
|
5792 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5793 |
3615 | 5794 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){ |
2804 | 5795 if(show_bits(gb, 23) == 0) break; |
5796 buf[i]= get_bits(gb, 8); | |
5797 } | |
5798 buf[i]=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
|
5799 |
761 | 5800 /* 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
|
5801 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
|
5802 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
|
5803 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
|
5804 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5805 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5806 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
|
5807 s->divx_packed= e==3 && last=='p'; |
8106
2f5101a67500
Only warn about "Invalid and inefficient vfw-avi packed B frames" once.
andoma
parents:
8042
diff
changeset
|
5808 if(s->divx_packed && !s->showed_packed_warning) { |
6893
72dafc993490
Warn about packed B-frames. (especially useful if the file in question is
michael
parents:
6655
diff
changeset
|
5809 av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n"); |
8106
2f5101a67500
Only warn about "Invalid and inefficient vfw-avi packed B frames" once.
andoma
parents:
8042
diff
changeset
|
5810 s->showed_packed_warning=1; |
2f5101a67500
Only warn about "Invalid and inefficient vfw-avi packed B frames" once.
andoma
parents:
8042
diff
changeset
|
5811 } |
0 | 5812 } |
2967 | 5813 |
761 | 5814 /* ffmpeg detection */ |
2805
55a6659fc2ee
fix user data parsing code so it suppors pre1 and cvs
michael
parents:
2804
diff
changeset
|
5815 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5816 if(e!=4) |
2967 | 5817 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5818 if(e!=4){ |
2814 | 5819 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1; |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5820 if (e>1) |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5821 build= (ver<<16) + (ver2<<8) + ver3; |
2814 | 5822 } |
5823 if(e!=4){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5824 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5825 s->lavc_build= 4600; |
63 | 5826 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5827 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5828 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5829 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5830 } |
2967 | 5831 |
6908 | 5832 /* Xvid detection */ |
761 | 5833 e=sscanf(buf, "XviD%d", &build); |
5834 if(e==1){ | |
5835 s->xvid_build= build; | |
5836 } | |
5837 | |
255 | 5838 //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
|
5839 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5840 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5841 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5842 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
|
5843 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5844 |
6481 | 5845 s->pict_type = get_bits(gb, 2) + FF_I_TYPE; /* pict type: I = 0 , P = 1 */ |
5846 if(s->pict_type==FF_B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5847 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n"); |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5848 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5849 } |
2967 | 5850 |
6481 | 5851 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5852 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5853 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5854 else |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
5855 s->decode_mb= ff_mpeg4_decode_mb; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5856 |
262 | 5857 time_incr=0; |
2967 | 5858 while (get_bits1(gb) != 0) |
0 | 5859 time_incr++; |
5860 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5861 check_marker(gb, "before time_increment"); |
2666 | 5862 |
5863 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5864 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n"); |
1068 | 5865 |
5866 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
5867 if(show_bits(gb, s->time_increment_bits+1)&1) break; | |
5868 } | |
1396 | 5869 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5870 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits); |
1068 | 5871 } |
2967 | 5872 |
1411 | 5873 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further |
5874 else time_increment= get_bits(gb, s->time_increment_bits); | |
2967 | 5875 |
1411 | 5876 // printf("%d %X\n", s->time_increment_bits, time_increment); |
2034 | 5877 //av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame); |
6481 | 5878 if(s->pict_type!=FF_B_TYPE){ |
324 | 5879 s->last_time_base= s->time_base; |
262 | 5880 s->time_base+= time_incr; |
2637 | 5881 s->time= s->time_base*s->avctx->time_base.den + time_increment; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5882 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5883 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5884 // 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
|
5885 s->time_base++; |
2637 | 5886 s->time+= s->avctx->time_base.den; |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5887 } |
664 | 5888 } |
324 | 5889 s->pp_time= s->time - s->last_non_b_time; |
5890 s->last_non_b_time= s->time; | |
262 | 5891 }else{ |
2637 | 5892 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment; |
664 | 5893 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
5894 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5895 // printf("messed up order, maybe after seeking? skipping current b frame\n"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5896 return FRAME_SKIPPED; |
335 | 5897 } |
3247 | 5898 ff_mpeg4_init_direct_mv(s); |
2967 | 5899 |
2034 | 5900 if(s->t_frame==0) s->t_frame= s->pb_time; |
664 | 5901 if(s->t_frame==0) s->t_frame=1; // 1/0 protection |
2967 | 5902 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) |
664 | 5903 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
2967 | 5904 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) |
664 | 5905 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
4346 | 5906 if(!s->progressive_sequence){ |
5907 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) | |
5908 return FRAME_SKIPPED; | |
5909 } | |
262 | 5910 } |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4001
diff
changeset
|
5911 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %"PRId64" last_base %d time %"PRId64" pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time); |
2967 | 5912 |
2813
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5913 if(s->avctx->time_base.num) |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5914 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num; |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5915 else |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5916 s->current_picture_ptr->pts= AV_NOPTS_VALUE; |
942 | 5917 if(s->avctx->debug&FF_DEBUG_PTS) |
2962 | 5918 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts); |
2034 | 5919 |
1068 | 5920 check_marker(gb, "before vop_coded"); |
2967 | 5921 |
0 | 5922 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5923 if (get_bits1(gb) != 1){ |
2271 | 5924 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
5925 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n"); | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5926 return FRAME_SKIPPED; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5927 } |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4001
diff
changeset
|
5928 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base, |
2967 | 5929 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time); |
6481 | 5930 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE |
5931 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { | |
0 | 5932 /* rounding type for motion estimation */ |
2979 | 5933 s->no_rounding = get_bits1(gb); |
63 | 5934 } else { |
2979 | 5935 s->no_rounding = 0; |
0 | 5936 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5937 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5938 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5939 if (s->shape != RECT_SHAPE) { |
6481 | 5940 if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) { |
63 | 5941 int width, height, hor_spat_ref, ver_spat_ref; |
2967 | 5942 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5943 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5944 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5945 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5946 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5947 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
|
5948 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5949 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 5950 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5951 skip_bits1(gb); /* change_CR_disable */ |
2967 | 5952 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5953 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5954 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 5955 } |
5956 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5957 //FIXME complexity estimation stuff |
2967 | 5958 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5959 if (s->shape != BIN_ONLY_SHAPE) { |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5960 skip_bits_long(gb, s->cplx_estimation_trash_i); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5961 if(s->pict_type != FF_I_TYPE) |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5962 skip_bits_long(gb, s->cplx_estimation_trash_p); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5963 if(s->pict_type == FF_B_TYPE) |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5964 skip_bits_long(gb, s->cplx_estimation_trash_b); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5965 |
1520 | 5966 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ]; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
5967 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5968 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
|
5969 s->alternate_scan= get_bits1(gb); |
661 | 5970 }else |
5971 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5972 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5973 |
718 | 5974 if(s->alternate_scan){ |
1273 | 5975 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
5976 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
5977 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
5978 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5979 } else{ |
1273 | 5980 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
5981 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
5982 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
5983 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5984 } |
2967 | 5985 |
6481 | 5986 if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
1914 | 5987 mpeg4_decode_sprite_trajectory(s, gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5988 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5989 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n"); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5990 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5991 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5992 if (s->shape != BIN_ONLY_SHAPE) { |
1644 | 5993 s->chroma_qscale= 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
|
5994 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5995 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n"); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5996 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
|
5997 } |
2967 | 5998 |
6481 | 5999 if (s->pict_type != FF_I_TYPE) { |
2979 | 6000 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
|
6001 if(s->f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6002 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n"); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
6003 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
|
6004 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6005 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6006 s->f_code=1; |
2967 | 6007 |
6481 | 6008 if (s->pict_type == FF_B_TYPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6009 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6010 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6011 s->b_code=1; |
906 | 6012 |
6013 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6014 av_log(s->avctx, AV_LOG_DEBUG, "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 dc:%d ce:%d/%d/%d\n", |
2967 | 6015 s->qscale, s->f_code, s->b_code, |
6481 | 6016 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")), |
2967 | 6017 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, |
930 | 6018 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6019 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold, s->cplx_estimation_trash_i, s->cplx_estimation_trash_p, s->cplx_estimation_trash_b); |
906 | 6020 } |
6021 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6022 if(!s->scalability){ |
6481 | 6023 if (s->shape!=RECT_SHAPE && s->pict_type!=FF_I_TYPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6024 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
|
6025 } |
575 | 6026 }else{ |
6027 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6028 int load_backward_shape= get_bits1(gb); |
575 | 6029 if(load_backward_shape){ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6030 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n"); |
575 | 6031 } |
6032 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6033 skip_bits(gb, 2); //ref_select_code |
63 | 6034 } |
6035 } | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6036 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/ |
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6037 // note we cannot detect divx5 without b-frames easily (although it's buggy too) |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
6038 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6039 av_log(s->avctx, AV_LOG_ERROR, "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
|
6040 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6041 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6042 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6043 s->picture_number++; // better than pic number==0 always ;) |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6044 |
2967 | 6045 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
498 | 6046 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; |
6047 | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1364
diff
changeset
|
6048 if(s->workaround_bugs&FF_BUG_EDGE){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6049 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6050 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6051 } |
63 | 6052 return 0; |
0 | 6053 } |
6054 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6055 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6056 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6057 * @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
|
6058 * 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
|
6059 * 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
|
6060 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6061 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
|
6062 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6063 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6064 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6065 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6066 align_get_bits(gb); |
2406 | 6067 |
8612 | 6068 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){ |
2406 | 6069 skip_bits(gb, 24); |
6070 if(get_bits(gb, 8) == 0xF0) | |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6071 goto end; |
2406 | 6072 } |
6073 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6074 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6075 for(;;) { |
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
|
6076 if(get_bits_count(gb) >= gb->size_in_bits){ |
2554
84a8f374bf63
fixing playback of xvid pretending to be divx (sample_vop_nc.avi)
michael
parents:
2522
diff
changeset
|
6077 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6078 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits); |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6079 return FRAME_SKIPPED; //divx bug |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6080 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6081 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6082 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6083 |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6084 /* use the bits after the test */ |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6085 v = get_bits(gb, 8); |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6086 startcode = ((startcode << 8) | v) & 0xffffffff; |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6087 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6088 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6089 continue; //no startcode |
2967 | 6090 |
942 | 6091 if(s->avctx->debug&FF_DEBUG_STARTCODE){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6092 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6093 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6094 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6095 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6096 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6097 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6098 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6099 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6100 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6101 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6102 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6103 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6104 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6105 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6106 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6107 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6108 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6109 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6110 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6111 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start"); |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6112 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6113 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6114 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6115 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6116 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start"); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6117 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6118 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6119 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6120 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb)); |
942 | 6121 } |
6122 | |
1512 | 6123 if(startcode >= 0x120 && startcode <= 0x12F){ |
2967 | 6124 if(decode_vol_header(s, gb) < 0) |
1396 | 6125 return -1; |
1512 | 6126 } |
6127 else if(startcode == USER_DATA_STARTCODE){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6128 decode_user_data(s, gb); |
1512 | 6129 } |
6130 else if(startcode == GOP_STARTCODE){ | |
942 | 6131 mpeg4_decode_gop_header(s, gb); |
1512 | 6132 } |
6133 else if(startcode == VOP_STARTCODE){ | |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6134 break; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6135 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6136 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6137 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6138 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6139 } |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6140 end: |
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6141 if(s->flags& CODEC_FLAG_LOW_DELAY) |
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6142 s->low_delay=1; |
8418
f75be04312dc
Fix PTS returned by the demuxers for mpeg4 without a decoder.
michael
parents:
8417
diff
changeset
|
6143 s->avctx->has_b_frames= !s->low_delay; |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6144 return decode_vop_header(s, gb); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6145 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6146 |
0 | 6147 /* don't understand why they choose a different header ! */ |
6148 int intel_h263_decode_picture_header(MpegEncContext *s) | |
6149 { | |
6150 int format; | |
6151 | |
6152 /* picture header */ | |
1257 | 6153 if (get_bits_long(&s->gb, 22) != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6154 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 6155 return -1; |
355 | 6156 } |
6157 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 6158 |
355 | 6159 if (get_bits1(&s->gb) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6160 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
2979 | 6161 return -1; /* marker */ |
355 | 6162 } |
6163 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6164 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 6165 return -1; /* h263 id */ |
6166 } | |
6167 skip_bits1(&s->gb); /* split screen off */ | |
6168 skip_bits1(&s->gb); /* camera off */ | |
6169 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 6170 |
6171 format = get_bits(&s->gb, 3); | |
355 | 6172 if (format != 7) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6173 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); |
0 | 6174 return -1; |
355 | 6175 } |
0 | 6176 s->h263_plus = 0; |
6177 | |
6481 | 6178 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); |
2967 | 6179 |
6180 s->unrestricted_mv = get_bits1(&s->gb); | |
0 | 6181 s->h263_long_vectors = s->unrestricted_mv; |
6182 | |
355 | 6183 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6184 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); |
2979 | 6185 return -1; /* SAC: off */ |
355 | 6186 } |
5405
f15e5b4909e1
remove "Advanced Prediction Mode not supported" spam
michael
parents:
5404
diff
changeset
|
6187 s->obmc= get_bits1(&s->gb); |
355 | 6188 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6189 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n"); |
2979 | 6190 return -1; /* PB frame mode */ |
355 | 6191 } |
0 | 6192 |
6193 /* skip unknown header garbage */ | |
21 | 6194 skip_bits(&s->gb, 41); |
0 | 6195 |
1644 | 6196 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 6197 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 6198 |
6199 /* PEI */ | |
21 | 6200 while (get_bits1(&s->gb) != 0) { |
6201 skip_bits(&s->gb, 8); | |
0 | 6202 } |
6203 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6204 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6205 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6206 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
|
6207 |
5404 | 6208 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
6209 show_pict_info(s); | |
6210 | |
0 | 6211 return 0; |
6212 } | |
144 | 6213 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6214 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
|
6215 { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6216 int format, width, height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6217 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6218 /* picture header */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6219 if (get_bits_long(&s->gb, 17) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6220 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6221 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6222 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6223 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
|
6224 if (format != 0 && format != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6225 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n"); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6226 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6227 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6228 s->h263_flv = format+1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6229 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
|
6230 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
|
6231 switch (format) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6232 case 0: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6233 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
|
6234 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
|
6235 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6236 case 1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6237 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
|
6238 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
|
6239 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6240 case 2: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6241 width = 352; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6242 height = 288; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6243 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6244 case 3: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6245 width = 176; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6246 height = 144; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6247 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6248 case 4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6249 width = 128; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6250 height = 96; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6251 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6252 case 5: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6253 width = 320; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6254 height = 240; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6255 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6256 case 6: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6257 width = 160; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6258 height = 120; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6259 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6260 default: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6261 width = height = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6262 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6263 } |
2422 | 6264 if(avcodec_check_dimensions(s->avctx, width, height)) |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6265 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6266 s->width = width; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6267 s->height = height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6268 |
6481 | 6269 s->pict_type = FF_I_TYPE + get_bits(&s->gb, 2); |
6270 s->dropable= s->pict_type > FF_P_TYPE; | |
1944 | 6271 if (s->dropable) |
6481 | 6272 s->pict_type = FF_P_TYPE; |
2967 | 6273 |
2979 | 6274 skip_bits1(&s->gb); /* deblocking flag */ |
1644 | 6275 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6276 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6277 s->h263_plus = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6278 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6279 s->unrestricted_mv = 1; |
1364 | 6280 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
|
6281 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6282 /* PEI */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6283 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
|
6284 skip_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6285 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6286 s->f_code = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6287 |
1364 | 6288 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6289 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n", |
2414
18d77621fbc7
print "D" instead of "P" for dropable frames in flv with -debug 1
michael
parents:
2406
diff
changeset
|
6290 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); |
1364 | 6291 } |
2967 | 6292 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6293 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6294 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
|
6295 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6296 return 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6297 } |