Mercurial > libavcodec.hg
annotate h263.c @ 10659:1f835b8a41c0 libavcodec
Boolify options passed to x264.
author | darkshikari |
---|---|
date | Tue, 08 Dec 2009 20:35:01 +0000 |
parents | 703cfed31320 |
children | f56b8a9be9e1 |
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 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8691
diff
changeset
|
30 * @file libavcodec/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" |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
43 #include "unary.h" |
0 | 44 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
45 //#undef NDEBUG |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
46 //#include <assert.h> |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
47 |
544 | 48 #define INTRA_MCBPC_VLC_BITS 6 |
1482 | 49 #define INTER_MCBPC_VLC_BITS 7 |
544 | 50 #define CBPY_VLC_BITS 6 |
51 #define MV_VLC_BITS 9 | |
52 #define DC_VLC_BITS 9 | |
53 #define SPRITE_TRAJ_VLC_BITS 6 | |
54 #define MB_TYPE_B_VLC_BITS 4 | |
55 #define TEX_VLC_BITS 9 | |
1655 | 56 #define H263_MBTYPE_B_VLC_BITS 6 |
57 #define CBPC_B_VLC_BITS 3 | |
544 | 58 |
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 |
262 | 68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 69 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
71 int n, int coded); | |
453 | 72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 74 int n, int coded, int intra, int rvlc); |
8739
037e54d6c9c3
Remove pointless '#if CONFIG_ENCODERS' around forward declarations.
diego
parents:
8718
diff
changeset
|
75 |
3781 | 76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr); |
1424 | 77 static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); | |
8739
037e54d6c9c3
Remove pointless '#if CONFIG_ENCODERS' around forward declarations.
diego
parents:
8718
diff
changeset
|
79 |
1914 | 80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); |
2003 | 81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding); |
1064 | 82 |
8590 | 83 #if CONFIG_ENCODERS |
1064 | 84 static uint8_t uni_DCtab_lum_len[512]; |
85 static uint8_t uni_DCtab_chrom_len[512]; | |
86 static uint16_t uni_DCtab_lum_bits[512]; | |
87 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
|
88 |
4655 | 89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
1064 | 90 static uint8_t fcode_tab[MAX_MV*2+1]; |
91 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
|
92 |
945 | 93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
94 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
96 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
2253 | 97 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; |
98 static uint8_t uni_h263_inter_rl_len [64*64*2*2]; | |
945 | 99 //#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
|
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 101 #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
|
102 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
103 /* 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
|
104 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
|
105 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
|
106 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
|
107 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
|
109 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
|
110 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
|
111 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
112 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
113 |
4672 | 114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3]; |
115 | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit |
8612 | 117 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1") |
2967 | 118 #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
|
119 #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
|
120 #endif |
293 | 121 |
0 | 122 int h263_get_picture_format(int width, int height) |
123 { | |
124 int format; | |
125 | |
126 if (width == 128 && height == 96) | |
355 | 127 format = 1; |
0 | 128 else if (width == 176 && height == 144) |
355 | 129 format = 2; |
0 | 130 else if (width == 352 && height == 288) |
355 | 131 format = 3; |
0 | 132 else if (width == 704 && height == 576) |
355 | 133 format = 4; |
0 | 134 else if (width == 1408 && height == 1152) |
355 | 135 format = 5; |
0 | 136 else |
137 format = 7; | |
138 return format; | |
139 } | |
140 | |
5403 | 141 static void show_pict_info(MpegEncContext *s){ |
142 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", | |
143 s->qscale, av_get_pict_type_char(s->pict_type), | |
144 s->gb.size_in_bits, 1-s->no_rounding, | |
145 s->obmc ? " AP" : "", | |
146 s->umvplus ? " UMV" : "", | |
147 s->h263_long_vectors ? " LONG" : "", | |
148 s->h263_plus ? " +" : "", | |
149 s->h263_aic ? " AIC" : "", | |
150 s->alt_inter_vlc ? " AIV" : "", | |
151 s->modified_quant ? " MQ" : "", | |
152 s->loop_filter ? " LOOP" : "", | |
153 s->h263_slice_structured ? " SS" : "", | |
154 s->avctx->time_base.den, s->avctx->time_base.num | |
155 ); | |
156 } | |
157 | |
8590 | 158 #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
|
159 |
1548 | 160 static void aspect_to_info(MpegEncContext * s, AVRational aspect){ |
887 | 161 int i; |
162 | |
1548 | 163 if(aspect.num==0) aspect= (AVRational){1,1}; |
164 | |
887 | 165 for(i=1; i<6; i++){ |
1548 | 166 if(av_cmp_q(pixel_aspect[i], aspect) == 0){ |
887 | 167 s->aspect_ratio_info=i; |
168 return; | |
169 } | |
170 } | |
2967 | 171 |
887 | 172 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 173 } |
174 | |
1354 | 175 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
0 | 176 { |
1354 | 177 int format; |
178 | |
179 align_put_bits(&s->pb); | |
180 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
181 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
|
182 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ |
2637 | 183 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp |
184 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
|
185 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
|
186 format = 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
187 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
|
188 format = 3; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
189 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
|
190 format = 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
191 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
|
192 format = 5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
193 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
|
194 format = 6; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
195 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
|
196 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
|
197 else |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
198 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
|
199 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
|
200 if (format == 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
201 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
|
202 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
|
203 } else if (format == 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
204 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
|
205 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
|
206 } |
6481 | 207 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
|
208 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
|
209 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
|
210 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
|
211 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
212 if(s->h263_aic){ |
2967 | 213 s->y_dc_scale_table= |
1639 | 214 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
|
215 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
216 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
217 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
|
218 } |
1354 | 219 } |
220 | |
221 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
222 { | |
1872 | 223 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref; |
224 int best_clock_code=1; | |
225 int best_divisor=60; | |
226 int best_error= INT_MAX; | |
2967 | 227 |
1872 | 228 if(s->h263_plus){ |
229 for(i=0; i<2; i++){ | |
230 int div, error; | |
2637 | 231 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
|
232 div= av_clip(div, 1, 127); |
4001 | 233 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div); |
1872 | 234 if(error < best_error){ |
235 best_error= error; | |
236 best_divisor= div; | |
237 best_clock_code= i; | |
238 } | |
239 } | |
240 } | |
241 s->custom_pcf= best_clock_code!=1 || best_divisor!=60; | |
242 coded_frame_rate= 1800000; | |
243 coded_frame_rate_base= (1000+best_clock_code)*best_divisor; | |
1354 | 244 |
245 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
|
246 |
231 | 247 /* Update the pointer to last GOB */ |
9431 | 248 s->ptr_lastgob = put_bits_ptr(&s->pb); |
231 | 249 put_bits(&s->pb, 22, 0x20); /* PSC */ |
2637 | 250 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp |
251 (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
|
252 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */ |
0 | 253 |
2979 | 254 put_bits(&s->pb, 1, 1); /* marker */ |
255 put_bits(&s->pb, 1, 0); /* h263 id */ | |
256 put_bits(&s->pb, 1, 0); /* split screen off */ | |
257 put_bits(&s->pb, 1, 0); /* camera off */ | |
258 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
2967 | 259 |
78 | 260 format = h263_get_picture_format(s->width, s->height); |
0 | 261 if (!s->h263_plus) { |
262 /* H.263v1 */ | |
263 put_bits(&s->pb, 3, format); | |
6481 | 264 put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE)); |
0 | 265 /* By now UMV IS DISABLED ON H.263v1, since the restrictions |
266 of H.263v1 UMV implies to check the predicted MV after | |
267 calculation of the current MB to see if we're on the limits */ | |
2979 | 268 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ |
269 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
270 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ | |
271 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ | |
0 | 272 put_bits(&s->pb, 5, s->qscale); |
2979 | 273 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
0 | 274 } else { |
1872 | 275 int ufep=1; |
0 | 276 /* H.263v2 */ |
277 /* H.263 Plus PTYPE */ | |
2967 | 278 |
0 | 279 put_bits(&s->pb, 3, 7); |
1872 | 280 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */ |
78 | 281 if (format == 7) |
282 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
283 else | |
284 put_bits(&s->pb, 3, format); | |
2967 | 285 |
1872 | 286 put_bits(&s->pb,1, s->custom_pcf); |
1661 | 287 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 288 put_bits(&s->pb,1,0); /* SAC: off */ |
1633 | 289 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
|
290 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
1644 | 291 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ |
1661 | 292 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ |
0 | 293 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ |
294 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
1637 | 295 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ |
1644 | 296 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ |
0 | 297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
298 put_bits(&s->pb,3,0); /* Reserved */ | |
2967 | 299 |
6481 | 300 put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE); |
2967 | 301 |
0 | 302 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ |
303 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
|
304 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 305 put_bits(&s->pb,2,0); /* Reserved */ |
306 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
2967 | 307 |
0 | 308 /* This should be here if PLUSPTYPE */ |
2979 | 309 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
310 | |
311 if (format == 7) { | |
78 | 312 /* Custom Picture Format (CPFMT) */ |
1548 | 313 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 314 |
315 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 316 put_bits(&s->pb,9,(s->width >> 2) - 1); |
317 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
318 put_bits(&s->pb,9,(s->height >> 2)); | |
1548 | 319 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
320 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
321 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
2979 | 322 } |
78 | 323 } |
1872 | 324 if(s->custom_pcf){ |
325 if(ufep){ | |
326 put_bits(&s->pb, 1, best_clock_code); | |
327 put_bits(&s->pb, 7, best_divisor); | |
328 } | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
329 put_sbits(&s->pb, 2, temp_ref>>8); |
1872 | 330 } |
2967 | 331 |
0 | 332 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
333 if (s->umvplus) |
1089 | 334 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
1644 | 335 //FIXME check actual requested range |
1089 | 336 put_bits(&s->pb,2,1); /* unlimited */ |
1661 | 337 if(s->h263_slice_structured) |
338 put_bits(&s->pb,2,0); /* no weird submodes */ | |
1089 | 339 |
0 | 340 put_bits(&s->pb, 5, s->qscale); |
341 } | |
342 | |
2979 | 343 put_bits(&s->pb, 1, 0); /* no PEI */ |
498 | 344 |
1670 | 345 if(s->h263_slice_structured){ |
346 put_bits(&s->pb, 1, 1); | |
2967 | 347 |
1670 | 348 assert(s->mb_x == 0 && s->mb_y == 0); |
349 ff_h263_encode_mba(s); | |
350 | |
351 put_bits(&s->pb, 1, 1); | |
352 } | |
353 | |
498 | 354 if(s->h263_aic){ |
2967 | 355 s->y_dc_scale_table= |
1639 | 356 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 357 }else{ |
358 s->y_dc_scale_table= | |
359 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
360 } | |
0 | 361 } |
362 | |
766 | 363 /** |
364 * Encodes a group of blocks header. | |
365 */ | |
1661 | 366 void h263_encode_gob_header(MpegEncContext * s, int mb_line) |
162 | 367 { |
1661 | 368 put_bits(&s->pb, 17, 1); /* GBSC */ |
369 | |
370 if(s->h263_slice_structured){ | |
371 put_bits(&s->pb, 1, 1); | |
372 | |
373 ff_h263_encode_mba(s); | |
374 | |
375 if(s->mb_num > 1583) | |
376 put_bits(&s->pb, 1, 1); | |
377 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
378 put_bits(&s->pb, 1, 1); | |
6481 | 379 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ |
1661 | 380 }else{ |
381 int gob_number= mb_line / s->gob_index; | |
382 | |
383 put_bits(&s->pb, 5, gob_number); /* GN */ | |
6481 | 384 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ |
1661 | 385 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
386 } | |
162 | 387 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
388 |
1492 | 389 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ |
390 int last=0; | |
391 int j; | |
392 int rate=0; | |
393 | |
394 for(j=1; j<=block_last_index; j++){ | |
395 const int index= scantable[j]; | |
396 int level= block[index]; | |
397 if(level){ | |
398 level+= 64; | |
399 if((level&(~127)) == 0){ | |
400 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; | |
401 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; | |
402 }else | |
403 rate += s->ac_esc_length; | |
404 | |
405 last= j; | |
406 } | |
407 } | |
2967 | 408 |
1492 | 409 return rate; |
410 } | |
411 | |
412 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
|
413 { |
1492 | 414 int score= 0; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
415 int i, n; |
903 | 416 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
|
417 |
1492 | 418 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); |
2967 | 419 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
420 for(n=0; n<6; n++){ |
1064 | 421 int16_t *ac_val, *ac_val1; |
2967 | 422 |
1492 | 423 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
|
424 |
266 | 425 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
|
426 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
427 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
|
428 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
|
429 /* top prediction */ |
266 | 430 ac_val-= s->block_wrap[n]*16; |
903 | 431 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
|
432 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
433 for(i=1; i<8; i++){ |
1092 | 434 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 435 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; |
1092 | 436 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
|
437 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
438 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
439 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
440 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
441 for(i=1; i<8; i++){ |
1092 | 442 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 443 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
1092 | 444 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
|
445 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
446 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
447 } |
1492 | 448 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
|
449 }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
|
450 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
|
451 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
452 ac_val-= 16; |
903 | 453 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
|
454 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
455 for(i=1; i<8; i++){ |
1092 | 456 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 457 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
|
458 ac_val1[i ]= level; |
1092 | 459 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
|
460 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
461 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
462 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
463 for(i=1; i<8; i++){ |
1092 | 464 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 465 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
|
466 ac_val1[i ]= level; |
1092 | 467 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
|
468 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
469 } |
1492 | 470 st[n]= s->intra_v_scantable.permutated; |
471 } | |
472 | |
473 for(i=63; i>0; i--) //FIXME optimize | |
474 if(block[n][ st[n][i] ]) break; | |
475 s->block_last_index[n]= i; | |
476 | |
477 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); | |
478 } | |
479 | |
480 return score < 0; | |
481 } | |
482 | |
483 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
484 { | |
485 int i, n; | |
486 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); | |
487 | |
488 for(n=0; n<6; n++){ | |
489 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
490 | |
491 st[n]= s->intra_scantable.permutated; | |
492 if(dir[n]){ | |
493 /* top prediction */ | |
494 for(i=1; i<8; i++){ | |
495 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8]; | |
496 } | |
497 }else{ | |
498 /* left prediction */ | |
499 for(i=1; i<8; i++){ | |
500 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ]; | |
501 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
502 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
503 } |
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 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
506 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
507 * 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
|
508 */ |
695 | 509 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
510 int i; |
903 | 511 int8_t * const qscale_table= s->current_picture.qscale_table; |
2967 | 512 |
4316 | 513 ff_init_qscale_tab(s); |
514 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
515 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
|
516 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
|
517 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
|
518 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
519 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
|
520 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
|
521 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
|
522 } |
1983 | 523 |
524 if(s->codec_id != CODEC_ID_H263P){ | |
525 for(i=1; i<s->mb_num; i++){ | |
526 int mb_xy= s->mb_index2xy[i]; | |
2967 | 527 |
1983 | 528 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ |
529 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER; | |
530 } | |
531 } | |
532 } | |
695 | 533 } |
534 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
535 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
536 * 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
|
537 */ |
695 | 538 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
539 int i; | |
903 | 540 int8_t * const qscale_table= s->current_picture.qscale_table; |
541 | |
695 | 542 ff_clean_h263_qscales(s); |
2967 | 543 |
6481 | 544 if(s->pict_type== FF_B_TYPE){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
545 int odd=0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
546 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */ |
2967 | 547 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
548 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
|
549 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
|
550 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
551 } |
2967 | 552 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
553 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
554 else odd=0; |
2967 | 555 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
556 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
|
557 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
|
558 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
|
559 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
|
560 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
|
561 qscale_table[mb_xy]= 31; |
2967 | 562 } |
563 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
564 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
|
565 int mb_xy= s->mb_index2xy[i]; |
1708 | 566 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ |
567 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
568 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
569 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
570 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
571 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
572 |
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
|
573 #endif //CONFIG_ENCODERS |
3247 | 574 |
8042 | 575 #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
|
576 #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
|
577 |
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
|
578 void ff_mpeg4_init_direct_mv(MpegEncContext *s){ |
3247 | 579 int i; |
580 for(i=0; i<tab_size; i++){ | |
581 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time; | |
582 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time; | |
583 } | |
584 } | |
585 | |
586 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){ | |
587 int xy= s->block_index[i]; | |
588 uint16_t time_pp= s->pp_time; | |
589 uint16_t time_pb= s->pb_time; | |
590 int p_mx, p_my; | |
591 | |
592 p_mx= s->next_picture.motion_val[0][xy][0]; | |
593 if((unsigned)(p_mx + tab_bias) < tab_size){ | |
594 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; | |
595 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
596 : s->direct_scale_mv[1][p_mx + tab_bias]; | |
597 }else{ | |
598 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx; | |
599 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
600 : p_mx*(time_pb - time_pp)/time_pp; | |
601 } | |
602 p_my= s->next_picture.motion_val[0][xy][1]; | |
603 if((unsigned)(p_my + tab_bias) < tab_size){ | |
604 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; | |
605 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
606 : s->direct_scale_mv[1][p_my + tab_bias]; | |
607 }else{ | |
608 s->mv[0][i][1] = p_my*time_pb/time_pp + my; | |
609 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
610 : p_my*(time_pb - time_pp)/time_pp; | |
611 } | |
612 } | |
613 | |
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
|
614 #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
|
615 #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
|
616 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
617 /** |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
618 * |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
619 * @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
|
620 */ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
621 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
|
622 const int mb_index= s->mb_x + s->mb_y*s->mb_stride; |
1708 | 623 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; |
9484
fb240cb99bcf
Remove useless init from ff_mpeg4_set_direct_mv() found by CSA.
michael
parents:
9481
diff
changeset
|
624 uint16_t time_pp; |
fb240cb99bcf
Remove useless init from ff_mpeg4_set_direct_mv() found by CSA.
michael
parents:
9481
diff
changeset
|
625 uint16_t time_pb; |
936 | 626 int i; |
2967 | 627 |
936 | 628 //FIXME avoid divides |
3247 | 629 // try special case with shifts for 1 and 3 B-frames? |
2967 | 630 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
631 if(IS_8X8(colocated_mb_type)){ |
936 | 632 s->mv_type = MV_TYPE_8X8; |
633 for(i=0; i<4; i++){ | |
3247 | 634 ff_mpeg4_set_one_direct_mv(s, mx, my, i); |
936 | 635 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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 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
|
637 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 638 s->mv_type = MV_TYPE_FIELD; |
639 for(i=0; i<2; i++){ | |
1948 | 640 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]]; |
3205 | 641 s->field_select[0][i]= field_select; |
642 s->field_select[1][i]= i; | |
936 | 643 if(s->top_field_first){ |
1948 | 644 time_pp= s->pp_field_time - field_select + i; |
645 time_pb= s->pb_field_time - field_select + i; | |
936 | 646 }else{ |
1948 | 647 time_pp= s->pp_field_time + field_select - i; |
648 time_pb= s->pb_field_time + field_select - i; | |
936 | 649 } |
1708 | 650 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; |
651 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; | |
652 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0] | |
653 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp; | |
2967 | 654 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] |
1708 | 655 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp; |
936 | 656 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
657 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
|
658 }else{ |
3247 | 659 ff_mpeg4_set_one_direct_mv(s, mx, my, 0); |
660 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0]; | |
661 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1]; | |
662 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0]; | |
663 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
|
664 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
|
665 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
|
666 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
|
667 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
|
668 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 669 } |
670 } | |
671 | |
1389 | 672 void ff_h263_update_motion_val(MpegEncContext * s){ |
673 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
|
674 //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
|
675 const int wrap = s->b8_stride; |
1389 | 676 const int xy = s->block_index[0]; |
2967 | 677 |
678 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped; | |
1389 | 679 |
680 if(s->mv_type != MV_TYPE_8X8){ | |
681 int motion_x, motion_y; | |
682 if (s->mb_intra) { | |
683 motion_x = 0; | |
684 motion_y = 0; | |
685 } else if (s->mv_type == MV_TYPE_16X16) { | |
686 motion_x = s->mv[0][0][0]; | |
687 motion_y = s->mv[0][0][1]; | |
688 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { | |
689 int i; | |
690 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; | |
691 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; | |
692 motion_x = (motion_x>>1) | (motion_x&1); | |
693 for(i=0; i<2; i++){ | |
1708 | 694 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0]; |
695 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1]; | |
1389 | 696 } |
1948 | 697 s->current_picture.ref_index[0][xy ]= |
698 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0]; | |
699 s->current_picture.ref_index[0][xy + wrap ]= | |
700 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1]; | |
1389 | 701 } |
1948 | 702 |
1389 | 703 /* 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
|
704 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
|
705 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
|
706 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
|
707 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
|
708 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
|
709 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
|
710 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
|
711 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; |
1389 | 712 } |
713 | |
714 if(s->encoding){ //FIXME encoding MUST be cleaned up | |
2967 | 715 if (s->mv_type == MV_TYPE_8X8) |
1389 | 716 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; |
1633 | 717 else if(s->mb_intra) |
718 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; | |
1389 | 719 else |
720 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | |
721 } | |
722 } | |
723 | |
8590 | 724 #if CONFIG_ENCODERS |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
725 |
2502 | 726 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){ |
727 int l, bit_size, code; | |
728 | |
729 if (val == 0) { | |
730 return mvtab[0][1]; | |
731 } else { | |
732 bit_size = f_code - 1; | |
733 /* modulo encoding */ | |
734 l= INT_BIT - 6 - bit_size; | |
735 val = (val<<l)>>l; | |
736 val--; | |
737 code = (val >> bit_size) + 1; | |
738 | |
739 return mvtab[code][1] + 1 + bit_size; | |
740 } | |
741 } | |
742 | |
743 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){ | |
744 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
2967 | 745 skip_put_bits(&s->pb, |
2502 | 746 h263_get_motion_length(s, x, f_code) |
747 +h263_get_motion_length(s, y, f_code)); | |
748 }else{ | |
749 ff_h263_encode_motion(s, x, f_code); | |
750 ff_h263_encode_motion(s, y, f_code); | |
751 } | |
752 } | |
753 | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
754 static inline int get_p_cbp(MpegEncContext * s, |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
755 DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
756 int motion_x, int motion_y){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
757 int cbp, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
758 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
759 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
760 int best_cbpy_score= INT_MAX; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
761 int best_cbpc_score= INT_MAX; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
762 int cbpc = (-1), cbpy= (-1); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
763 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
|
764 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
|
765 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
766 for(i=0; i<4; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
767 int score= inter_MCBPC_bits[i + offset] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
768 if(i&1) score += s->coded_score[5]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
769 if(i&2) score += s->coded_score[4]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
770 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
771 if(score < best_cbpc_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
772 best_cbpc_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
773 cbpc= 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 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
776 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
777 for(i=0; i<16; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
778 int score= cbpy_tab[i ^ 0xF][1] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
779 if(i&1) score += s->coded_score[3]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
780 if(i&2) score += s->coded_score[2]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
781 if(i&4) score += s->coded_score[1]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
782 if(i&8) score += s->coded_score[0]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
783 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
784 if(score < best_cbpy_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
785 best_cbpy_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
786 cbpy= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
787 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
788 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
789 cbp= cbpc + 4*cbpy; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
790 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
|
791 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
|
792 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
793 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
794 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
795 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
796 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
|
797 s->block_last_index[i]= -1; |
8288 | 798 s->dsp.clear_block(s->block[i]); |
1490
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 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
801 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
802 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
803 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
804 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
805 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
806 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
807 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
808 return cbp; |
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 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
|
812 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
|
813 int cbp=0, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
814 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
815 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
816 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
|
817 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 818 |
1490
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->coded_score[i] < 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
821 score += s->coded_score[i]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
822 cbp |= 1 << (5 - i); |
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 } |
2967 | 825 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
826 if(cbp){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
827 int zero_score= -6; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
828 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
|
829 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
|
830 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
831 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
832 zero_score*= lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
833 if(zero_score <= score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
834 cbp=0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
835 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
836 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
837 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
838 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
839 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
|
840 s->block_last_index[i]= -1; |
8288 | 841 s->dsp.clear_block(s->block[i]); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
842 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
843 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
844 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
845 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
846 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
847 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
848 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
849 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
850 return cbp; |
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 |
2967 | 853 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], |
2502 | 854 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){ |
855 int i; | |
2967 | 856 |
2502 | 857 if(scan_table){ |
858 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
859 for (i = 0; i < 6; i++) { | |
860 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i])); | |
861 } | |
862 }else{ | |
863 /* encode each block */ | |
864 for (i = 0; i < 6; i++) { | |
865 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb); | |
866 } | |
867 } | |
868 }else{ | |
869 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
870 for (i = 0; i < 6; i++) { | |
871 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated)); | |
872 } | |
873 }else{ | |
874 /* encode each block */ | |
875 for (i = 0; i < 6; i++) { | |
876 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb); | |
877 } | |
878 } | |
879 } | |
880 } | |
881 | |
8644 | 882 static const int dquant_code[5]= {1,0,9,2,3}; |
883 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
884 void mpeg4_encode_mb(MpegEncContext * s, |
2979 | 885 DCTELEM block[6][64], |
886 int motion_x, int motion_y) | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
887 { |
1057 | 888 int cbpc, cbpy, pred_x, pred_y; |
453 | 889 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
6481 | 890 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb; |
891 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2 : &s->pb; | |
453 | 892 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; |
2967 | 893 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
894 // 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
|
895 if (!s->mb_intra) { |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
896 int i, cbp; |
2967 | 897 |
6481 | 898 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
|
899 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ |
324 | 900 int mb_type= mb_type_table[s->mv_dir]; |
1708 | 901 |
324 | 902 if(s->mb_x==0){ |
1708 | 903 for(i=0; i<2; i++){ |
2967 | 904 s->last_mv[i][0][0]= |
905 s->last_mv[i][0][1]= | |
906 s->last_mv[i][1][0]= | |
1708 | 907 s->last_mv[i][1][1]= 0; |
908 } | |
324 | 909 } |
2967 | 910 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
911 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
912 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
913 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
914 |
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
|
915 /* 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
|
916 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 917 s->skip_count++; |
2967 | 918 s->mv[0][0][0]= |
919 s->mv[0][0][1]= | |
920 s->mv[1][0][0]= | |
324 | 921 s->mv[1][0][1]= 0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
922 s->mv_dir= MV_DIR_FORWARD; //doesn't matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
923 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
|
924 // s->mb_skipped=1; |
903 | 925 |
324 | 926 return; |
927 } | |
2967 | 928 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
929 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); |
2967 | 930 |
324 | 931 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
932 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
933 assert(s->dquant==0); |
2967 | 934 |
324 | 935 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 936 |
937 if(interleaved_stats){ | |
938 s->misc_bits++; | |
939 s->last_bits++; | |
940 } | |
324 | 941 s->skip_count++; |
942 return; | |
943 } | |
2967 | 944 |
2979 | 945 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
324 | 946 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
|
947 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) |
324 | 948 if(cbp) put_bits(&s->pb, 6, cbp); |
2967 | 949 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
950 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
951 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
952 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
953 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
954 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
955 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
956 s->qscale -= s->dquant; |
2967 | 957 |
697 | 958 if(!s->progressive_sequence){ |
959 if(cbp) | |
960 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
|
961 if(mb_type) // not direct mode |
1708 | 962 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD); |
697 | 963 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
964 |
453 | 965 if(interleaved_stats){ |
1164 | 966 s->misc_bits+= get_bits_diff(s); |
453 | 967 } |
295 | 968 |
1708 | 969 if(mb_type == 0){ |
970 assert(s->mv_dir & MV_DIRECT); | |
2502 | 971 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
|
972 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
973 s->f_count++; |
1708 | 974 }else{ |
975 assert(mb_type > 0 && mb_type < 4); | |
976 if(s->mv_type != MV_TYPE_FIELD){ | |
977 if(s->mv_dir & MV_DIR_FORWARD){ | |
2502 | 978 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0], |
979 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
1708 | 980 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0]; |
981 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1]; | |
982 s->f_count++; | |
983 } | |
984 if(s->mv_dir & MV_DIR_BACKWARD){ | |
2502 | 985 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0], |
986 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
1708 | 987 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0]; |
988 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1]; | |
989 s->b_count++; | |
990 } | |
991 }else{ | |
992 if(s->mv_dir & MV_DIR_FORWARD){ | |
993 put_bits(&s->pb, 1, s->field_select[0][0]); | |
994 put_bits(&s->pb, 1, s->field_select[0][1]); | |
995 } | |
996 if(s->mv_dir & MV_DIR_BACKWARD){ | |
997 put_bits(&s->pb, 1, s->field_select[1][0]); | |
998 put_bits(&s->pb, 1, s->field_select[1][1]); | |
999 } | |
1000 if(s->mv_dir & MV_DIR_FORWARD){ | |
1001 for(i=0; i<2; i++){ | |
2502 | 1002 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] , |
1003 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code); | |
1708 | 1004 s->last_mv[0][i][0]= s->mv[0][i][0]; |
1005 s->last_mv[0][i][1]= s->mv[0][i][1]*2; | |
1006 } | |
1007 s->f_count++; | |
1008 } | |
1009 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1010 for(i=0; i<2; i++){ | |
2502 | 1011 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] , |
1012 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code); | |
1708 | 1013 s->last_mv[1][i][0]= s->mv[1][i][0]; |
1014 s->last_mv[1][i][1]= s->mv[1][i][1]*2; | |
1015 } | |
1016 s->b_count++; | |
1017 } | |
1018 } | |
324 | 1019 } |
453 | 1020 |
1021 if(interleaved_stats){ | |
1164 | 1022 s->mv_bits+= get_bits_diff(s); |
453 | 1023 } |
295 | 1024 |
2502 | 1025 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb); |
453 | 1026 |
1027 if(interleaved_stats){ | |
1164 | 1028 s->p_tex_bits+= get_bits_diff(s); |
453 | 1029 } |
1708 | 1030 |
6481 | 1031 }else{ /* s->pict_type==FF_B_TYPE */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1032 cbp= get_p_cbp(s, block, motion_x, motion_y); |
2967 | 1033 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1034 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
2967 | 1035 /* 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
|
1036 why didn't they just compress the skip-mb bits instead of reusing them ?! */ |
331 | 1037 if(s->max_b_frames>0){ |
1038 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1039 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1040 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1041 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1042 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1043 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1044 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
|
1045 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
|
1046 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1047 offset= x + y*s->linesize; |
903 | 1048 p_pic= s->new_picture.data[0] + offset; |
2967 | 1049 |
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
|
1050 s->mb_skipped=1; |
331 | 1051 for(i=0; i<s->max_b_frames; i++){ |
339 | 1052 uint8_t *b_pic; |
1053 int diff; | |
903 | 1054 Picture *pic= s->reordered_input_picture[i+1]; |
1055 | |
6481 | 1056 if(pic==NULL || pic->pict_type!=FF_B_TYPE) break; |
903 | 1057 |
3068 | 1058 b_pic= pic->data[0] + offset; |
1059 if(pic->type != FF_BUFFER_TYPE_SHARED) | |
1060 b_pic+= INPLACE_OFFSET; | |
2979 | 1061 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
|
1062 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
|
1063 s->mb_skipped=0; |
331 | 1064 break; |
1065 } | |
1066 } | |
1067 }else | |
2967 | 1068 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
|
1069 |
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
|
1070 if(s->mb_skipped==1){ |
331 | 1071 /* skip macroblock */ |
1072 put_bits(&s->pb, 1, 1); | |
453 | 1073 |
1074 if(interleaved_stats){ | |
1075 s->misc_bits++; | |
1076 s->last_bits++; | |
1077 } | |
331 | 1078 s->skip_count++; |
2967 | 1079 |
331 | 1080 return; |
1081 } | |
295 | 1082 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1083 |
2979 | 1084 put_bits(&s->pb, 1, 0); /* mb coded */ |
1633 | 1085 cbpc = cbp & 3; |
1086 cbpy = cbp >> 2; | |
1087 cbpy ^= 0xf; | |
324 | 1088 if(s->mv_type==MV_TYPE_16X16){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1089 if(s->dquant) cbpc+= 8; |
324 | 1090 put_bits(&s->pb, |
1091 inter_MCBPC_bits[cbpc], | |
1092 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1093 |
453 | 1094 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
|
1095 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1096 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 1097 |
1098 if(!s->progressive_sequence){ | |
1099 if(cbp) | |
1100 put_bits(pb2, 1, s->interlaced_dct); | |
1708 | 1101 put_bits(pb2, 1, 0); |
697 | 1102 } |
2967 | 1103 |
453 | 1104 if(interleaved_stats){ |
1164 | 1105 s->misc_bits+= get_bits_diff(s); |
453 | 1106 } |
324 | 1107 |
1108 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1109 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1110 |
2502 | 1111 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1112 motion_y - pred_y, s->f_code); | |
1708 | 1113 }else if(s->mv_type==MV_TYPE_FIELD){ |
1114 if(s->dquant) cbpc+= 8; | |
1115 put_bits(&s->pb, | |
1116 inter_MCBPC_bits[cbpc], | |
1117 inter_MCBPC_code[cbpc]); | |
1118 | |
1119 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1120 if(s->dquant) | |
1121 put_bits(pb2, 2, dquant_code[s->dquant+2]); | |
1122 | |
1123 assert(!s->progressive_sequence); | |
1124 if(cbp) | |
1125 put_bits(pb2, 1, s->interlaced_dct); | |
1126 put_bits(pb2, 1, 1); | |
2967 | 1127 |
1708 | 1128 if(interleaved_stats){ |
1129 s->misc_bits+= get_bits_diff(s); | |
1130 } | |
1131 | |
1132 /* motion vectors: 16x8 interlaced mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1133 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1708 | 1134 pred_y /=2; |
2967 | 1135 |
1708 | 1136 put_bits(&s->pb, 1, s->field_select[0][0]); |
1137 put_bits(&s->pb, 1, s->field_select[0][1]); | |
2967 | 1138 |
2502 | 1139 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x, |
1140 s->mv[0][0][1] - pred_y, s->f_code); | |
1141 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x, | |
1142 s->mv[0][1][1] - pred_y, s->f_code); | |
324 | 1143 }else{ |
1708 | 1144 assert(s->mv_type==MV_TYPE_8X8); |
324 | 1145 put_bits(&s->pb, |
1633 | 1146 inter_MCBPC_bits[cbpc+16], |
1147 inter_MCBPC_code[cbpc+16]); | |
453 | 1148 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
1149 | |
757 | 1150 if(!s->progressive_sequence){ |
1151 if(cbp) | |
1152 put_bits(pb2, 1, s->interlaced_dct); | |
1153 } | |
2967 | 1154 |
453 | 1155 if(interleaved_stats){ |
1164 | 1156 s->misc_bits+= get_bits_diff(s); |
453 | 1157 } |
324 | 1158 |
1159 for(i=0; i<4; i++){ | |
1160 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1161 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
324 | 1162 |
2502 | 1163 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, |
1164 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); | |
324 | 1165 } |
1166 } | |
453 | 1167 |
2967 | 1168 if(interleaved_stats){ |
1164 | 1169 s->mv_bits+= get_bits_diff(s); |
453 | 1170 } |
324 | 1171 |
2502 | 1172 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb); |
453 | 1173 |
1174 if(interleaved_stats){ | |
1164 | 1175 s->p_tex_bits+= get_bits_diff(s); |
453 | 1176 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
1177 s->f_count++; |
295 | 1178 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1179 } else { |
324 | 1180 int cbp; |
2967 | 1181 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
|
1182 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1183 int zigzag_last_index[6]; |
2979 | 1184 uint8_t *scan_table[6]; |
1057 | 1185 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1186 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1187 for(i=0; i<6; i++){ |
2003 | 1188 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
|
1189 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1190 |
1492 | 1191 if(s->flags & CODEC_FLAG_AC_PRED){ |
1192 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); | |
1193 if(!s->ac_pred) | |
1194 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
|
1195 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1196 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1197 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
|
1198 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1199 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1200 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1201 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1202 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1203 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1204 cbp |= 1 << (5 - i); |
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 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1207 cbpc = cbp & 3; |
6481 | 1208 if (s->pict_type == FF_I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1209 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1210 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1211 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1212 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1213 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1214 if(s->dquant) cbpc+=8; |
2979 | 1215 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
|
1216 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1217 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1218 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1219 } |
453 | 1220 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
|
1221 cbpy = cbp >> 2; |
453 | 1222 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
|
1223 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1224 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 1225 |
697 | 1226 if(!s->progressive_sequence){ |
1227 put_bits(dc_pb, 1, s->interlaced_dct); | |
1228 } | |
1229 | |
453 | 1230 if(interleaved_stats){ |
1164 | 1231 s->misc_bits+= get_bits_diff(s); |
453 | 1232 } |
286 | 1233 |
2502 | 1234 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
|
1235 |
453 | 1236 if(interleaved_stats){ |
1164 | 1237 s->i_tex_bits+= get_bits_diff(s); |
453 | 1238 } |
286 | 1239 s->i_count++; |
1240 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1241 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
1492 | 1242 if(s->ac_pred) |
1243 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
|
1244 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1245 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1246 |
0 | 1247 void h263_encode_mb(MpegEncContext * s, |
2979 | 1248 DCTELEM block[6][64], |
1249 int motion_x, int motion_y) | |
0 | 1250 { |
1251 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 1252 int16_t pred_dc; |
1253 int16_t rec_intradc[6]; | |
3781 | 1254 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
|
1255 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
2967 | 1256 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1257 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
324 | 1258 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1259 /* compute cbp */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1260 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
|
1261 |
1789 | 1262 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) { |
324 | 1263 /* skip macroblock */ |
1264 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
|
1265 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1266 s->misc_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1267 s->last_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1268 } |
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
|
1269 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
|
1270 |
324 | 1271 return; |
1272 } | |
2979 | 1273 put_bits(&s->pb, 1, 0); /* mb coded */ |
2967 | 1274 |
324 | 1275 cbpc = cbp & 3; |
1637 | 1276 cbpy = cbp >> 2; |
1277 if(s->alt_inter_vlc==0 || cbpc!=3) | |
1278 cbpy ^= 0xF; | |
695 | 1279 if(s->dquant) cbpc+= 8; |
1633 | 1280 if(s->mv_type==MV_TYPE_16X16){ |
1281 put_bits(&s->pb, | |
1282 inter_MCBPC_bits[cbpc], | |
1283 inter_MCBPC_code[cbpc]); | |
1284 | |
1285 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1286 if(s->dquant) | |
1287 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
2967 | 1288 |
1633 | 1289 if(interleaved_stats){ |
1290 s->misc_bits+= get_bits_diff(s); | |
1291 } | |
1292 | |
1293 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1294 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1295 |
1296 if (!s->umvplus) { | |
2502 | 1297 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1298 motion_y - pred_y, 1); | |
1633 | 1299 } |
1300 else { | |
1301 h263p_encode_umotion(s, motion_x - pred_x); | |
1302 h263p_encode_umotion(s, motion_y - pred_y); | |
1303 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1304 /* To prevent Start Code emulation */ | |
1305 put_bits(&s->pb,1,1); | |
1306 } | |
1307 }else{ | |
1308 put_bits(&s->pb, | |
1309 inter_MCBPC_bits[cbpc+16], | |
1310 inter_MCBPC_code[cbpc+16]); | |
1311 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1312 if(s->dquant) | |
1313 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1314 | |
1315 if(interleaved_stats){ | |
1316 s->misc_bits+= get_bits_diff(s); | |
1317 } | |
1318 | |
1319 for(i=0; i<4; i++){ | |
1320 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1321 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 1322 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1323 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
|
1324 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
2967 | 1325 if (!s->umvplus) { |
2502 | 1326 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1327 motion_y - pred_y, 1); | |
1633 | 1328 } |
1329 else { | |
1330 h263p_encode_umotion(s, motion_x - pred_x); | |
1331 h263p_encode_umotion(s, motion_y - pred_y); | |
1332 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1333 /* To prevent Start Code emulation */ | |
1334 put_bits(&s->pb,1,1); | |
1335 } | |
1336 } | |
324 | 1337 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1338 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1339 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1340 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
|
1341 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1342 } else { |
1639 | 1343 assert(s->mb_intra); |
2967 | 1344 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1345 cbp = 0; |
1666 | 1346 if (s->h263_aic) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1347 /* Predict DC */ |
1666 | 1348 for(i=0; i<6; i++) { |
1064 | 1349 int16_t level = block[i][0]; |
1666 | 1350 int scale; |
2967 | 1351 |
1666 | 1352 if(i<4) scale= s->y_dc_scale; |
1353 else scale= s->c_dc_scale; | |
1354 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1355 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
|
1356 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1357 /* Quant */ |
1666 | 1358 if (level >= 0) |
1359 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
|
1360 else |
1666 | 1361 level = (level - (scale>>1))/scale; |
2967 | 1362 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1363 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1364 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
|
1365 s->block_last_index[i] = -1; |
1666 | 1366 |
1367 if(!s->modified_quant){ | |
1368 if (level < -127) | |
1369 level = -127; | |
1370 else if (level > 127) | |
1371 level = 127; | |
1372 } | |
1373 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1374 block[i][0] = level; |
2967 | 1375 /* Reconstruction */ |
1666 | 1376 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
|
1377 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1378 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1379 //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
|
1380 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1381 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1382 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1383 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1384 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
|
1385 rec_intradc[i] = 2047; |
2967 | 1386 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1387 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1388 *dc_ptr[i] = rec_intradc[i]; |
1666 | 1389 if (s->block_last_index[i] >= 0) |
1390 cbp |= 1 << (5 - i); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1391 } |
1666 | 1392 }else{ |
1393 for(i=0; i<6; i++) { | |
1394 /* compute cbp */ | |
1395 if (s->block_last_index[i] >= 1) | |
1396 cbp |= 1 << (5 - i); | |
1397 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1398 } |
0 | 1399 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1400 cbpc = cbp & 3; |
6481 | 1401 if (s->pict_type == FF_I_TYPE) { |
695 | 1402 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
|
1403 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1404 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1405 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1406 } else { |
695 | 1407 if(s->dquant) cbpc+=8; |
2979 | 1408 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
|
1409 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1410 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1411 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1412 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1413 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1414 /* XXX: currently, we do not try to use ac prediction */ |
2979 | 1415 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
|
1416 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1417 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1418 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 1419 if(s->dquant) |
1420 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
|
1421 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1422 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1423 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
|
1424 } |
0 | 1425 } |
1426 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1427 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
|
1428 /* encode each block */ |
1354 | 1429 h263_encode_block(s, block[i], i); |
2967 | 1430 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1431 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1432 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
|
1433 block[i][0] = rec_intradc[i]; |
2967 | 1434 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1435 } |
0 | 1436 } |
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 if (!s->mb_intra) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1440 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
|
1441 s->f_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1442 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1443 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
|
1444 s->i_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1445 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1446 } |
0 | 1447 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1448 #endif |
0 | 1449 |
1656 | 1450 void ff_h263_loop_filter(MpegEncContext * s){ |
1644 | 1451 int qp_c; |
1452 const int linesize = s->linesize; | |
1453 const int uvlinesize= s->uvlinesize; | |
1454 const int xy = s->mb_y * s->mb_stride + s->mb_x; | |
1455 uint8_t *dest_y = s->dest[0]; | |
1456 uint8_t *dest_cb= s->dest[1]; | |
1457 uint8_t *dest_cr= s->dest[2]; | |
2967 | 1458 |
6481 | 1459 // if(s->pict_type==FF_B_TYPE && !s->readable) return; |
1644 | 1460 |
1461 /* | |
1462 Diag Top | |
1463 Left Center | |
1464 */ | |
1465 if(!IS_SKIP(s->current_picture.mb_type[xy])){ | |
1466 qp_c= s->qscale; | |
1467 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c); | |
1468 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1469 }else | |
1470 qp_c= 0; | |
1471 | |
1472 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
|
1473 int qp_dt, qp_tt, qp_tc; |
1644 | 1474 |
1475 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
|
1476 qp_tt=0; |
2967 | 1477 else |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1478 qp_tt= s->current_picture.qscale_table[xy-s->mb_stride]; |
1644 | 1479 |
2967 | 1480 if(qp_c) |
1644 | 1481 qp_tc= qp_c; |
1482 else | |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1483 qp_tc= qp_tt; |
2967 | 1484 |
1644 | 1485 if(qp_tc){ |
1486 const int chroma_qp= s->chroma_qscale_table[qp_tc]; | |
1487 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); | |
1488 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc); | |
2967 | 1489 |
1644 | 1490 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); |
1491 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1492 } | |
2967 | 1493 |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1494 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
|
1495 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_tt); |
2967 | 1496 |
1644 | 1497 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
|
1498 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
|
1499 qp_dt= qp_tt; |
1644 | 1500 else |
1501 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride]; | |
2967 | 1502 |
1644 | 1503 if(qp_dt){ |
1504 const int chroma_qp= s->chroma_qscale_table[qp_dt]; | |
1505 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt); | |
1506 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp); | |
2178 | 1507 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp); |
1644 | 1508 } |
1509 } | |
1510 } | |
1511 | |
1512 if(qp_c){ | |
1513 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c); | |
1514 if(s->mb_y + 1 == s->mb_height) | |
1515 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1516 } | |
2967 | 1517 |
1644 | 1518 if(s->mb_x){ |
1519 int qp_lc; | |
1520 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1])) | |
1521 qp_lc= qp_c; | |
1522 else | |
1523 qp_lc= s->current_picture.qscale_table[xy-1]; | |
2967 | 1524 |
1644 | 1525 if(qp_lc){ |
1526 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); | |
1527 if(s->mb_y + 1 == s->mb_height){ | |
1528 const int chroma_qp= s->chroma_qscale_table[qp_lc]; | |
1529 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc); | |
1530 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); | |
1531 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1532 } | |
1533 } | |
1534 } | |
1535 } | |
1536 | |
8590 | 1537 #if CONFIG_ENCODERS |
3781 | 1538 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
|
1539 { |
9481
44ea854a14b7
Remove several useless writes to variables, found by CSA.
michael
parents:
9465
diff
changeset
|
1540 int x, y, wrap, a, c, pred_dc; |
3781 | 1541 int16_t *dc_val; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1542 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1543 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1544 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1545 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
|
1546 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
|
1547 wrap = s->b8_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1548 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
|
1549 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1550 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1551 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1552 wrap = s->mb_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1553 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
|
1554 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1555 /* B C |
2967 | 1556 * A X |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1557 */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1558 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
|
1559 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1560 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1561 /* 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
|
1562 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
|
1563 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
|
1564 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
|
1565 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1566 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1567 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1568 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1569 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1570 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1571 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1572 pred_dc = c; |
2967 | 1573 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1574 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1575 *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
|
1576 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1577 } |
3777 | 1578 #endif /* CONFIG_ENCODERS */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1579 |
1057 | 1580 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
|
1581 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1582 int x, y, wrap, a, c, pred_dc, scale, i; |
3781 | 1583 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1584 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1585 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1586 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1587 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
|
1588 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
|
1589 wrap = s->b8_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1590 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1591 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1592 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1593 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1594 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1595 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1596 wrap = s->mb_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1597 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1598 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
|
1599 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1600 } |
2967 | 1601 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1602 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1603 ac_val1 = ac_val; |
2967 | 1604 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1605 /* B C |
2967 | 1606 * A X |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1607 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1608 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1609 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1610 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1611 /* No prediction outside GOB boundary */ |
1639 | 1612 if(s->first_slice_line && n!=3){ |
1613 if(n!=2) c= 1024; | |
1614 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; | |
1615 } | |
2967 | 1616 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1617 if (s->ac_pred) { |
1639 | 1618 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1619 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1620 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1621 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1622 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1623 for(i=1;i<8;i++) { |
1092 | 1624 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
|
1625 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1626 pred_dc = a; |
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 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1629 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1630 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1631 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1632 for(i=1;i<8;i++) { |
1092 | 1633 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
|
1634 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1635 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1636 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1637 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1638 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1639 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1640 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1641 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1642 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1643 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1644 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1645 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1646 } |
2967 | 1647 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1648 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1649 block[0]=block[0]*scale + pred_dc; |
2967 | 1650 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1651 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1652 block[0] = 0; |
2967 | 1653 else |
1639 | 1654 block[0] |= 1; |
2967 | 1655 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1656 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1657 dc_val[(x) + (y) * wrap] = block[0]; |
2967 | 1658 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1659 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1660 for(i=1;i<8;i++) |
1092 | 1661 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
|
1662 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1663 for(i=1;i<8;i++) |
1092 | 1664 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
|
1665 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1666 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1667 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir, |
0 | 1668 int *px, int *py) |
1669 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1670 int wrap; |
1655 | 1671 int16_t *A, *B, *C, (*mot_val)[2]; |
1672 static const int off[4]= {2, 1, 1, -1}; | |
1673 | |
1674 wrap = s->b8_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1675 mot_val = s->current_picture.motion_val[dir] + s->block_index[block]; |
1655 | 1676 |
1677 A = mot_val[ - 1]; | |
1678 /* special case for first (slice) line */ | |
1679 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
|
1680 // we can't just change some MVs to simulate that as we need them for the B frames (and ME) |
1655 | 1681 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( |
1682 if(block==0){ //most common case | |
1683 if(s->mb_x == s->resync_mb_x){ //rare | |
1684 *px= *py = 0; | |
1685 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1686 C = mot_val[off[block] - wrap]; | |
1687 if(s->mb_x==0){ | |
1688 *px = C[0]; | |
1689 *py = C[1]; | |
1690 }else{ | |
1691 *px = mid_pred(A[0], 0, C[0]); | |
1692 *py = mid_pred(A[1], 0, C[1]); | |
1693 } | |
1694 }else{ | |
1695 *px = A[0]; | |
1696 *py = A[1]; | |
1697 } | |
1698 }else if(block==1){ | |
1699 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1700 C = mot_val[off[block] - wrap]; | |
1701 *px = mid_pred(A[0], 0, C[0]); | |
1702 *py = mid_pred(A[1], 0, C[1]); | |
1703 }else{ | |
1704 *px = A[0]; | |
1705 *py = A[1]; | |
1706 } | |
1707 }else{ /* block==2*/ | |
1708 B = mot_val[ - wrap]; | |
1709 C = mot_val[off[block] - wrap]; | |
1710 if(s->mb_x == s->resync_mb_x) //rare | |
1711 A[0]=A[1]=0; | |
2967 | 1712 |
1655 | 1713 *px = mid_pred(A[0], B[0], C[0]); |
1714 *py = mid_pred(A[1], B[1], C[1]); | |
1715 } | |
1716 } else { | |
1717 B = mot_val[ - wrap]; | |
1718 C = mot_val[off[block] - wrap]; | |
1719 *px = mid_pred(A[0], B[0], C[0]); | |
1720 *py = mid_pred(A[1], B[1], C[1]); | |
1721 } | |
1722 return *mot_val; | |
1723 } | |
1724 | |
8590 | 1725 #if CONFIG_ENCODERS |
2017 | 1726 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1727 { |
702 | 1728 int range, l, bit_size, sign, code, bits; |
0 | 1729 |
1730 if (val == 0) { | |
1731 /* zero vector */ | |
1732 code = 0; | |
1733 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1734 } else { | |
324 | 1735 bit_size = f_code - 1; |
0 | 1736 range = 1 << bit_size; |
1737 /* modulo encoding */ | |
2093 | 1738 l= INT_BIT - 6 - bit_size; |
1739 val = (val<<l)>>l; | |
702 | 1740 sign = val>>31; |
1741 val= (val^sign)-sign; | |
1742 sign&=1; | |
2093 | 1743 |
312 | 1744 val--; |
1745 code = (val >> bit_size) + 1; | |
1746 bits = val & (range - 1); | |
0 | 1747 |
2967 | 1748 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); |
0 | 1749 if (bit_size > 0) { |
1750 put_bits(&s->pb, bit_size, bits); | |
1751 } | |
1752 } | |
1753 } | |
1754 | |
78 | 1755 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1756 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1757 { | |
2967 | 1758 short sval = 0; |
78 | 1759 short i = 0; |
1760 short n_bits = 0; | |
1761 short temp_val; | |
1762 int code = 0; | |
1763 int tcode; | |
2967 | 1764 |
78 | 1765 if ( val == 0) |
1766 put_bits(&s->pb, 1, 1); | |
1767 else if (val == 1) | |
1768 put_bits(&s->pb, 3, 0); | |
1769 else if (val == -1) | |
1770 put_bits(&s->pb, 3, 2); | |
1771 else { | |
2967 | 1772 |
78 | 1773 sval = ((val < 0) ? (short)(-val):(short)val); |
1774 temp_val = sval; | |
2967 | 1775 |
78 | 1776 while (temp_val != 0) { |
1777 temp_val = temp_val >> 1; | |
1778 n_bits++; | |
1779 } | |
2967 | 1780 |
78 | 1781 i = n_bits - 1; |
1782 while (i > 0) { | |
1783 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1784 tcode = (tcode << 1) | 1; | |
1785 code = (code << 2) | tcode; | |
1786 i--; | |
1787 } | |
1788 code = ((code << 1) | (val < 0)) << 1; | |
1789 put_bits(&s->pb, (2*n_bits)+1, code); | |
1790 //printf("\nVal = %d\tCode = %d", sval, code); | |
1791 } | |
1792 } | |
1793 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1794 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
|
1795 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1796 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1797 int mv; |
2967 | 1798 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1799 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
|
1800 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
|
1801 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1802 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1803 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1804 else{ |
9465
9dcb191f1df3
Remove unused variable in init_mv_penalty_and_fcode() found by CSA.
michael
parents:
9458
diff
changeset
|
1805 int val, bit_size, code; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1806 |
1893
779bdf5063ce
1000000l (using uninitalized variable for initalizing bits per MV table)
michael
parents:
1873
diff
changeset
|
1807 bit_size = f_code - 1; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1808 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1809 val=mv; |
2967 | 1810 if (val < 0) |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1811 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1812 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1813 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1814 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1815 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1816 }else{ |
2985 | 1817 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
|
1818 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1819 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1820 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1821 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
|
1822 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1823 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1824 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1825 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
|
1826 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
|
1827 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1828 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1829 } |
287 | 1830 |
1831 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1832 umv_fcode_tab[mv]= 1; | |
1833 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1834 } |
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
|
1835 |
468 | 1836 static void init_uni_dc_tab(void) |
293 | 1837 { |
1838 int level, uni_code, uni_len; | |
1839 | |
312 | 1840 for(level=-256; level<256; level++){ |
293 | 1841 int size, v, l; |
1842 /* find number of bits */ | |
1843 size = 0; | |
1844 v = abs(level); | |
1845 while (v) { | |
1846 v >>= 1; | |
2979 | 1847 size++; |
293 | 1848 } |
1849 | |
1850 if (level < 0) | |
1851 l= (-level) ^ ((1 << size) - 1); | |
1852 else | |
1853 l= level; | |
1854 | |
1855 /* luminance */ | |
1856 uni_code= DCtab_lum[size][0]; | |
1857 uni_len = DCtab_lum[size][1]; | |
1858 | |
1859 if (size > 0) { | |
1860 uni_code<<=size; uni_code|=l; | |
1861 uni_len+=size; | |
1862 if (size > 8){ | |
1863 uni_code<<=1; uni_code|=1; | |
1864 uni_len++; | |
1865 } | |
1866 } | |
1013 | 1867 uni_DCtab_lum_bits[level+256]= uni_code; |
1868 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1869 |
1870 /* chrominance */ | |
1871 uni_code= DCtab_chrom[size][0]; | |
1872 uni_len = DCtab_chrom[size][1]; | |
2967 | 1873 |
293 | 1874 if (size > 0) { |
1875 uni_code<<=size; uni_code|=l; | |
1876 uni_len+=size; | |
1877 if (size > 8){ | |
1878 uni_code<<=1; uni_code|=1; | |
1879 uni_len++; | |
1880 } | |
1881 } | |
1013 | 1882 uni_DCtab_chrom_bits[level+256]= uni_code; |
1883 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1884 |
1885 } | |
1886 } | |
1887 | |
1064 | 1888 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
|
1889 int slevel, run, last; |
2967 | 1890 |
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
|
1891 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
|
1892 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
|
1893 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1894 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
|
1895 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
|
1896 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
|
1897 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
|
1898 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
|
1899 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
|
1900 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
|
1901 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
|
1902 int level1, run1; |
2967 | 1903 |
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
|
1904 len_tab[index]= 100; |
2967 | 1905 |
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
|
1906 /* 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
|
1907 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
|
1908 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
|
1909 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
|
1910 bits=bits*2+sign; len++; |
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 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
|
1913 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
|
1914 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
|
1915 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
|
1917 /* 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
|
1918 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
|
1919 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
|
1920 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
|
1921 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
|
1922 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
|
1923 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
|
1924 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
|
1925 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
|
1926 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
|
1927 bits=bits*2+sign; len++; |
2967 | 1928 |
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
|
1929 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
|
1930 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
|
1931 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
|
1932 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
2967 | 1934 #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
|
1935 #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
|
1936 /* 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
|
1937 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
|
1938 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
|
1939 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
|
1940 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
|
1941 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
|
1942 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
|
1943 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
|
1944 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
|
1945 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
|
1946 bits=bits*2+sign; len++; |
2967 | 1947 |
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
|
1948 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
|
1949 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
|
1950 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
|
1951 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
2967 | 1953 #endif |
1954 /* 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
|
1955 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
|
1956 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
|
1957 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
|
1958 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
|
1959 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
|
1960 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
|
1961 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
|
1962 bits=bits*2+1; len++; //marker |
2967 | 1963 |
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
|
1964 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
|
1965 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
|
1966 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
|
1967 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1968 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 |
2253 | 1973 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
1974 int slevel, run, last; | |
2967 | 1975 |
2253 | 1976 assert(MAX_LEVEL >= 64); |
1977 assert(MAX_RUN >= 63); | |
1978 | |
1979 for(slevel=-64; slevel<64; slevel++){ | |
1980 if(slevel==0) continue; | |
1981 for(run=0; run<64; run++){ | |
1982 for(last=0; last<=1; last++){ | |
1983 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); | |
1984 int level= slevel < 0 ? -slevel : slevel; | |
1985 int sign= slevel < 0 ? 1 : 0; | |
1986 int bits, len, code; | |
2967 | 1987 |
2253 | 1988 len_tab[index]= 100; |
2967 | 1989 |
2253 | 1990 /* ESC0 */ |
1991 code= get_rl_index(rl, last, run, level); | |
1992 bits= rl->table_vlc[code][0]; | |
1993 len= rl->table_vlc[code][1]; | |
1994 bits=bits*2+sign; len++; | |
2967 | 1995 |
2253 | 1996 if(code!=rl->n && len < len_tab[index]){ |
1997 if(bits_tab) bits_tab[index]= bits; | |
1998 len_tab [index]= len; | |
1999 } | |
2000 /* ESC */ | |
2001 bits= rl->table_vlc[rl->n][0]; | |
2002 len = rl->table_vlc[rl->n][1]; | |
2003 bits=bits*2+last; len++; | |
2004 bits=bits*64+run; len+=6; | |
2005 bits=bits*256+(level&0xff); len+=8; | |
2967 | 2006 |
2253 | 2007 if(len < len_tab[index]){ |
2008 if(bits_tab) bits_tab[index]= bits; | |
2009 len_tab [index]= len; | |
2010 } | |
2011 } | |
2012 } | |
2013 } | |
2014 } | |
2015 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2016 void h263_encode_init(MpegEncContext *s) |
0 | 2017 { |
2018 static int done = 0; | |
2019 | |
2020 if (!done) { | |
2021 done = 1; | |
293 | 2022 |
2023 init_uni_dc_tab(); | |
2024 | |
4668 | 2025 init_rl(&rl_inter, static_rl_table_store[0]); |
2026 init_rl(&rl_intra, static_rl_table_store[1]); | |
2027 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
2967 | 2028 |
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
|
2029 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
|
2030 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
|
2031 |
2253 | 2032 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); |
2033 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len); | |
2034 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2035 init_mv_penalty_and_fcode(s); |
0 | 2036 } |
936 | 2037 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p |
2967 | 2038 |
2253 | 2039 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len; |
2040 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; | |
2041 if(s->h263_aic){ | |
2042 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len; | |
2043 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; | |
2044 } | |
2045 s->ac_esc_length= 7+1+6+8; | |
2046 | |
287 | 2047 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 2048 switch(s->codec_id){ |
2049 case CODEC_ID_MPEG4: | |
2050 s->fcode_tab= fcode_tab; | |
2051 s->min_qcoeff= -2048; | |
2052 s->max_qcoeff= 2047; | |
945 | 2053 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
2054 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
2055 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
2056 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 2057 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
2058 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 2059 s->ac_esc_length= 7+2+1+6+1+12+1; |
1799 | 2060 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; |
2061 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
2062 | |
1424 | 2063 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ |
1483 | 2064 |
1424 | 2065 s->avctx->extradata= av_malloc(1024); |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1521
diff
changeset
|
2066 init_put_bits(&s->pb, s->avctx->extradata, 1024); |
2967 | 2067 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2068 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
|
2069 mpeg4_encode_visual_object_header(s); |
1424 | 2070 mpeg4_encode_vol_header(s, 0, 0); |
2071 | |
2072 // ff_mpeg4_stuffing(&s->pb); ? | |
2073 flush_put_bits(&s->pb); | |
1786 | 2074 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3; |
1424 | 2075 } |
2967 | 2076 |
344 | 2077 break; |
2078 case CODEC_ID_H263P: | |
1666 | 2079 if(s->umvplus) |
2080 s->fcode_tab= umv_fcode_tab; | |
2081 if(s->modified_quant){ | |
2082 s->min_qcoeff= -2047; | |
2083 s->max_qcoeff= 2047; | |
2084 }else{ | |
2085 s->min_qcoeff= -127; | |
2086 s->max_qcoeff= 127; | |
2087 } | |
344 | 2088 break; |
2967 | 2089 //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
|
2090 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2091 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2092 s->min_qcoeff= -1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2093 s->max_qcoeff= 1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2094 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2095 s->min_qcoeff= -127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2096 s->max_qcoeff= 127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2097 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2098 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2099 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
|
2100 break; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2101 default: //nothing needed - default table already set in mpegvideo.c |
1089 | 2102 s->min_qcoeff= -127; |
344 | 2103 s->max_qcoeff= 127; |
498 | 2104 s->y_dc_scale_table= |
2105 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 2106 } |
0 | 2107 } |
2108 | |
1034 | 2109 /** |
2110 * encodes a 8x8 block. | |
2111 * @param block the 8x8 block | |
2112 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2113 */ | |
0 | 2114 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
2115 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2116 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
|
2117 RLTable *rl; |
0 | 2118 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2119 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2120 if (s->mb_intra && !s->h263_aic) { |
231 | 2121 /* DC coef */ |
1089 | 2122 level = block[0]; |
0 | 2123 /* 255 cannot be represented, so we clamp */ |
2124 if (level > 254) { | |
2125 level = 254; | |
2126 block[0] = 254; | |
2127 } | |
231 | 2128 /* 0 cannot be represented also */ |
1089 | 2129 else if (level < 1) { |
231 | 2130 level = 1; |
2131 block[0] = 1; | |
2132 } | |
1090 | 2133 if (level == 128) //FIXME check rv10 |
1089 | 2134 put_bits(&s->pb, 8, 0xff); |
2135 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
|
2136 put_bits(&s->pb, 8, level); |
1089 | 2137 i = 1; |
0 | 2138 } else { |
1089 | 2139 i = 0; |
2140 if (s->h263_aic && s->mb_intra) | |
2141 rl = &rl_intra_aic; | |
2967 | 2142 |
1637 | 2143 if(s->alt_inter_vlc && !s->mb_intra){ |
2144 int aic_vlc_bits=0; | |
2145 int inter_vlc_bits=0; | |
2146 int wrong_pos=-1; | |
2147 int aic_code; | |
2967 | 2148 |
1637 | 2149 last_index = s->block_last_index[n]; |
2150 last_non_zero = i - 1; | |
2151 for (; i <= last_index; i++) { | |
2152 j = s->intra_scantable.permutated[i]; | |
2153 level = block[j]; | |
2154 if (level) { | |
2155 run = i - last_non_zero - 1; | |
2156 last = (i == last_index); | |
2967 | 2157 |
1663 | 2158 if(level<0) level= -level; |
2967 | 2159 |
1637 | 2160 code = get_rl_index(rl, last, run, level); |
2161 aic_code = get_rl_index(&rl_intra_aic, last, run, level); | |
2162 inter_vlc_bits += rl->table_vlc[code][1]+1; | |
2163 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; | |
2164 | |
2165 if (code == rl->n) { | |
1663 | 2166 inter_vlc_bits += 1+6+8-1; |
2967 | 2167 } |
1637 | 2168 if (aic_code == rl_intra_aic.n) { |
1663 | 2169 aic_vlc_bits += 1+6+8-1; |
1637 | 2170 wrong_pos += run + 1; |
2171 }else | |
2172 wrong_pos += wrong_run[aic_code]; | |
2173 last_non_zero = i; | |
2967 | 2174 } |
1637 | 2175 } |
2176 i = 0; | |
2177 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) | |
2178 rl = &rl_intra_aic; | |
2179 } | |
0 | 2180 } |
2967 | 2181 |
0 | 2182 /* AC coefs */ |
2183 last_index = s->block_last_index[n]; | |
2184 last_non_zero = i - 1; | |
2185 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
2186 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
|
2187 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2188 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2189 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
|
2190 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2191 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2192 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2193 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2194 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2195 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2196 } |
0 | 2197 code = get_rl_index(rl, last, run, level); |
2198 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2199 if (code == rl->n) { | |
1354 | 2200 if(s->h263_flv <= 1){ |
0 | 2201 put_bits(&s->pb, 1, last); |
2202 put_bits(&s->pb, 6, run); | |
2967 | 2203 |
1089 | 2204 assert(slevel != 0); |
2205 | |
2967 | 2206 if(level < 128) |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2207 put_sbits(&s->pb, 8, slevel); |
1089 | 2208 else{ |
2209 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
|
2210 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
|
2211 put_sbits(&s->pb, 6, slevel>>5); |
1089 | 2212 } |
1354 | 2213 }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
|
2214 if(level < 64) { // 7-bit level |
1354 | 2215 put_bits(&s->pb, 1, 0); |
2216 put_bits(&s->pb, 1, last); | |
2217 put_bits(&s->pb, 6, run); | |
2218 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2219 put_sbits(&s->pb, 7, slevel); |
1354 | 2220 } else { |
2221 /* 11-bit level */ | |
2222 put_bits(&s->pb, 1, 1); | |
2223 put_bits(&s->pb, 1, last); | |
2224 put_bits(&s->pb, 6, run); | |
2225 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2226 put_sbits(&s->pb, 11, slevel); |
1354 | 2227 } |
2228 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2229 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2230 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
|
2231 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2232 last_non_zero = i; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2233 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2234 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2235 } |
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
|
2236 |
0 | 2237 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2238 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2239 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2240 */ |
453 | 2241 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 2242 { |
2243 int length; | |
2244 put_bits(pbc, 1, 0); | |
1786 | 2245 length= (-put_bits_count(pbc))&7; |
453 | 2246 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 2247 } |
2248 | |
327 | 2249 /* 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
|
2250 void ff_set_mpeg4_time(MpegEncContext * s){ |
6481 | 2251 if(s->pict_type==FF_B_TYPE){ |
3247 | 2252 ff_mpeg4_init_direct_mv(s); |
327 | 2253 }else{ |
2254 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
|
2255 s->time_base= s->time/s->avctx->time_base.den; |
327 | 2256 } |
2257 } | |
2258 | |
942 | 2259 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
2260 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
|
2261 int64_t time; |
2967 | 2262 |
942 | 2263 put_bits(&s->pb, 16, 0); |
2264 put_bits(&s->pb, 16, GOP_STARTCODE); | |
2967 | 2265 |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2266 time= s->current_picture_ptr->pts; |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2267 if(s->reordered_input_picture[1]) |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2268 time= FFMIN(time, s->reordered_input_picture[1]->pts); |
2637 | 2269 time= time*s->avctx->time_base.num; |
2270 | |
2271 seconds= time/s->avctx->time_base.den; | |
942 | 2272 minutes= seconds/60; seconds %= 60; |
2273 hours= minutes/60; minutes %= 60; | |
2274 hours%=24; | |
2275 | |
2276 put_bits(&s->pb, 5, hours); | |
2277 put_bits(&s->pb, 6, minutes); | |
2278 put_bits(&s->pb, 1, 1); | |
2279 put_bits(&s->pb, 6, seconds); | |
2967 | 2280 |
2281 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); | |
942 | 2282 put_bits(&s->pb, 1, 0); //broken link == NO |
2967 | 2283 |
2284 s->last_time_base= time / s->avctx->time_base.den; | |
942 | 2285 |
2286 ff_mpeg4_stuffing(&s->pb); | |
2287 } | |
2288 | |
2289 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
2290 int profile_and_level_indication; | |
2291 int vo_ver_id; | |
2967 | 2292 |
2167 | 2293 if(s->avctx->profile != FF_PROFILE_UNKNOWN){ |
2294 profile_and_level_indication = s->avctx->profile << 4; | |
2295 }else if(s->max_b_frames || s->quarter_sample){ | |
2296 profile_and_level_indication= 0xF0; // adv simple | |
2297 }else{ | |
2298 profile_and_level_indication= 0x00; // simple | |
2299 } | |
2300 | |
2301 if(s->avctx->level != FF_LEVEL_UNKNOWN){ | |
2302 profile_and_level_indication |= s->avctx->level; | |
2303 }else{ | |
2304 profile_and_level_indication |= 1; //level 1 | |
2305 } | |
2306 | |
2307 if(profile_and_level_indication>>4 == 0xF){ | |
942 | 2308 vo_ver_id= 5; |
2309 }else{ | |
2310 vo_ver_id= 1; | |
2311 } | |
2167 | 2312 |
942 | 2313 //FIXME levels |
2314 | |
2315 put_bits(&s->pb, 16, 0); | |
2316 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2317 |
942 | 2318 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2319 |
942 | 2320 put_bits(&s->pb, 16, 0); |
2321 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
2967 | 2322 |
942 | 2323 put_bits(&s->pb, 1, 1); |
2324 put_bits(&s->pb, 4, vo_ver_id); | |
2325 put_bits(&s->pb, 3, 1); //priority | |
2967 | 2326 |
942 | 2327 put_bits(&s->pb, 4, 1); //visual obj type== video obj |
2967 | 2328 |
942 | 2329 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME |
2330 | |
2331 ff_mpeg4_stuffing(&s->pb); | |
2332 } | |
2333 | |
2334 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 2335 { |
942 | 2336 int vo_ver_id; |
336 | 2337 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
2338 if (!CONFIG_MPEG4_ENCODER) return; |
5275
91416b4f1929
Better place to disable some mpeg4 code and ensure that
aurel
parents:
5274
diff
changeset
|
2339 |
942 | 2340 if(s->max_b_frames || s->quarter_sample){ |
2341 vo_ver_id= 5; | |
923 | 2342 s->vo_type= ADV_SIMPLE_VO_TYPE; |
2343 }else{ | |
942 | 2344 vo_ver_id= 1; |
923 | 2345 s->vo_type= SIMPLE_VO_TYPE; |
2346 } | |
336 | 2347 |
263 | 2348 put_bits(&s->pb, 16, 0); |
942 | 2349 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 2350 put_bits(&s->pb, 16, 0); |
942 | 2351 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 2352 |
2979 | 2353 put_bits(&s->pb, 1, 0); /* random access vol */ |
2354 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
|
2355 if(s->workaround_bugs & FF_BUG_MS) { |
2979 | 2356 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
|
2357 } else { |
2979 | 2358 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
2359 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
2360 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
|
2361 } |
2967 | 2362 |
1548 | 2363 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 2364 |
2365 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
1548 | 2366 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
2367 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
2368 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
|
2369 } |
336 | 2370 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2371 if(s->workaround_bugs & FF_BUG_MS) { // |
2979 | 2372 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
|
2373 } else { |
2979 | 2374 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ |
2375 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
|
2376 put_bits(&s->pb, 1, s->low_delay); |
2979 | 2377 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ |
2378 } | |
2379 | |
2380 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ | |
2381 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2967 | 2382 |
2637 | 2383 put_bits(&s->pb, 16, s->avctx->time_base.den); |
263 | 2384 if (s->time_increment_bits < 1) |
2385 s->time_increment_bits = 1; | |
2979 | 2386 put_bits(&s->pb, 1, 1); /* marker bit */ |
2387 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
2388 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2389 put_bits(&s->pb, 13, s->width); /* vol width */ | |
2390 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2391 put_bits(&s->pb, 13, s->height); /* vol height */ | |
2392 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 2393 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
2979 | 2394 put_bits(&s->pb, 1, 1); /* obmc disable */ |
263 | 2395 if (vo_ver_id == 1) { |
2979 | 2396 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ |
942 | 2397 }else{ |
2979 | 2398 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ |
2399 } | |
2400 | |
2401 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ | |
2402 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ | |
1411 | 2403 |
2404 if(s->mpeg_quant){ | |
2405 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
2406 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
2407 } | |
599 | 2408 |
263 | 2409 if (vo_ver_id != 1) |
936 | 2410 put_bits(&s->pb, 1, s->quarter_sample); |
2979 | 2411 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 2412 s->resync_marker= s->rtp_mode; |
2413 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
2414 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
2415 if(s->data_partitioning){ | |
2979 | 2416 put_bits(&s->pb, 1, 0); /* no rvlc */ |
453 | 2417 } |
2418 | |
263 | 2419 if (vo_ver_id != 1){ |
2979 | 2420 put_bits(&s->pb, 1, 0); /* newpred */ |
2421 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
2422 } | |
2423 put_bits(&s->pb, 1, 0); /* scalability */ | |
2967 | 2424 |
453 | 2425 ff_mpeg4_stuffing(&s->pb); |
676 | 2426 |
2427 /* user data */ | |
1092 | 2428 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 2429 put_bits(&s->pb, 16, 0); |
2979 | 2430 put_bits(&s->pb, 16, 0x1B2); /* user_data */ |
2431 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); | |
676 | 2432 } |
263 | 2433 } |
2434 | |
2435 /* write mpeg4 VOP header */ | |
2436 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
2437 { | |
324 | 2438 int time_incr; |
2439 int time_div, time_mod; | |
2967 | 2440 |
6481 | 2441 if(s->pict_type==FF_I_TYPE){ |
953 | 2442 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
|
2443 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
|
2444 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
|
2445 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
|
2446 mpeg4_encode_vol_header(s, 0, 0); |
942 | 2447 } |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2448 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
|
2449 mpeg4_encode_gop_header(s); |
453 | 2450 } |
2967 | 2451 |
6481 | 2452 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
|
2453 |
2637 | 2454 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE); |
2967 | 2455 |
2979 | 2456 put_bits(&s->pb, 16, 0); /* vop header */ |
2457 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ | |
2458 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | |
324 | 2459 |
2679 | 2460 assert(s->time>=0); |
2637 | 2461 time_div= s->time/s->avctx->time_base.den; |
2462 time_mod= s->time%s->avctx->time_base.den; | |
324 | 2463 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
|
2464 assert(time_incr >= 0); |
324 | 2465 while(time_incr--) |
2466 put_bits(&s->pb, 1, 1); | |
2967 | 2467 |
0 | 2468 put_bits(&s->pb, 1, 0); |
2469 | |
2979 | 2470 put_bits(&s->pb, 1, 1); /* marker */ |
2471 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ | |
2472 put_bits(&s->pb, 1, 1); /* marker */ | |
2473 put_bits(&s->pb, 1, 1); /* vop coded */ | |
6481 | 2474 if ( s->pict_type == FF_P_TYPE |
2475 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
2979 | 2476 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
2477 } | |
2478 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 2479 if(!s->progressive_sequence){ |
1659 | 2480 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); |
697 | 2481 put_bits(&s->pb, 1, s->alternate_scan); |
2482 } | |
263 | 2483 //FIXME sprite stuff |
0 | 2484 |
2485 put_bits(&s->pb, 5, s->qscale); | |
2486 | |
6481 | 2487 if (s->pict_type != FF_I_TYPE) |
2979 | 2488 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ |
6481 | 2489 if (s->pict_type == FF_B_TYPE) |
2979 | 2490 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ |
0 | 2491 // printf("****frame %d\n", picture_number); |
2492 } | |
2493 | |
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
|
2494 #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
|
2495 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2496 /** |
1034 | 2497 * predicts the dc. |
2003 | 2498 * encoding quantized level -> quantized diff |
2967 | 2499 * decoding quantized diff -> quantized level |
1034 | 2500 * @param n block index (0-3 are luma, 4-5 are chroma) |
2501 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
2502 */ | |
2003 | 2503 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) |
0 | 2504 { |
2003 | 2505 int a, b, c, wrap, pred, scale, ret; |
3781 | 2506 int16_t *dc_val; |
0 | 2507 |
2508 /* find prediction */ | |
2509 if (n < 4) { | |
2979 | 2510 scale = s->y_dc_scale; |
0 | 2511 } else { |
2979 | 2512 scale = s->c_dc_scale; |
0 | 2513 } |
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
|
2514 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
|
2515 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
|
2516 |
266 | 2517 wrap= s->block_wrap[n]; |
2518 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 2519 |
2520 /* B C | |
2967 | 2521 * A X |
0 | 2522 */ |
266 | 2523 a = dc_val[ - 1]; |
2524 b = dc_val[ - 1 - wrap]; | |
2525 c = dc_val[ - wrap]; | |
0 | 2526 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2527 /* 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
|
2528 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2529 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2530 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
|
2531 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2532 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
|
2533 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2534 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2535 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2536 |
0 | 2537 if (abs(a - b) < abs(b - c)) { |
2979 | 2538 pred = c; |
0 | 2539 *dir_ptr = 1; /* top */ |
2540 } else { | |
2979 | 2541 pred = a; |
0 | 2542 *dir_ptr = 0; /* left */ |
2543 } | |
2544 /* 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
|
2545 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 2546 |
2003 | 2547 if(encoding){ |
2548 ret = level - pred; | |
2549 }else{ | |
2550 level += pred; | |
2551 ret= level; | |
7831 | 2552 if(s->error_recognition>=3){ |
2003 | 2553 if(level<0){ |
2554 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
2555 return -1; | |
2556 } | |
2557 if(level*scale > 2048 + scale){ | |
2558 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
2559 return -1; | |
2560 } | |
2561 } | |
2562 } | |
2563 level *=scale; | |
2004 | 2564 if(level&(~2047)){ |
2967 | 2565 if(level<0) |
2004 | 2566 level=0; |
2567 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP)) | |
2568 level=2047; | |
2569 } | |
2003 | 2570 dc_val[0]= level; |
2571 | |
2572 return ret; | |
0 | 2573 } |
2574 | |
1034 | 2575 /** |
2576 * predicts the ac. | |
2577 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2578 * @param dir the ac prediction direction | |
2579 */ | |
1008 | 2580 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 2581 int dir) |
2582 { | |
266 | 2583 int i; |
1064 | 2584 int16_t *ac_val, *ac_val1; |
903 | 2585 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2586 |
2587 /* find prediction */ | |
266 | 2588 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 2589 ac_val1 = ac_val; |
2590 if (s->ac_pred) { | |
2591 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
|
2592 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 2593 /* left prediction */ |
2594 ac_val -= 16; | |
2967 | 2595 |
903 | 2596 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 2597 /* same qscale */ |
2598 for(i=1;i<8;i++) { | |
1092 | 2599 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 2600 } |
2601 }else{ | |
2602 /* different qscale, we must rescale */ | |
2603 for(i=1;i<8;i++) { | |
1092 | 2604 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 2605 } |
0 | 2606 } |
2607 } 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
|
2608 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 2609 /* top prediction */ |
266 | 2610 ac_val -= 16 * s->block_wrap[n]; |
575 | 2611 |
903 | 2612 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 2613 /* same qscale */ |
2614 for(i=1;i<8;i++) { | |
1092 | 2615 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 2616 } |
2617 }else{ | |
2618 /* different qscale, we must rescale */ | |
2619 for(i=1;i<8;i++) { | |
1092 | 2620 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 2621 } |
0 | 2622 } |
2623 } | |
2624 } | |
2625 /* left copy */ | |
2626 for(i=1;i<8;i++) | |
1092 | 2627 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 2628 |
0 | 2629 /* top copy */ |
2630 for(i=1;i<8;i++) | |
1092 | 2631 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 2632 |
0 | 2633 } |
2634 | |
8590 | 2635 #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
|
2636 |
1034 | 2637 /** |
2638 * encodes the dc value. | |
2639 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2640 */ | |
453 | 2641 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
|
2642 { |
293 | 2643 #if 1 |
453 | 2644 // if(level<-255 || level>255) printf("dc overflow\n"); |
293 | 2645 level+=256; |
2646 if (n < 4) { | |
2979 | 2647 /* luminance */ |
2648 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); | |
293 | 2649 } else { |
2979 | 2650 /* chrominance */ |
2651 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); | |
293 | 2652 } |
2653 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2654 int size, v; |
0 | 2655 /* find number of bits */ |
2656 size = 0; | |
2657 v = abs(level); | |
2658 while (v) { | |
2979 | 2659 v >>= 1; |
2660 size++; | |
0 | 2661 } |
2662 | |
2663 if (n < 4) { | |
2979 | 2664 /* luminance */ |
2665 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
0 | 2666 } else { |
2979 | 2667 /* chrominance */ |
2668 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
0 | 2669 } |
2670 | |
2671 /* encode remaining bits */ | |
2672 if (size > 0) { | |
2979 | 2673 if (level < 0) |
2674 level = (-level) ^ ((1 << size) - 1); | |
2675 put_bits(&s->pb, size, level); | |
2676 if (size > 8) | |
2677 put_bits(&s->pb, 1, 1); | |
0 | 2678 } |
293 | 2679 #endif |
0 | 2680 } |
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
|
2681 |
2502 | 2682 static inline int mpeg4_get_dc_length(int level, int n){ |
2683 if (n < 4) { | |
2684 return uni_DCtab_lum_len[level + 256]; | |
2685 } else { | |
2686 return uni_DCtab_chrom_len[level + 256]; | |
2687 } | |
2688 } | |
2689 | |
1034 | 2690 /** |
2691 * encodes a 8x8 block | |
2692 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2693 */ | |
2967 | 2694 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2695 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2696 { |
751 | 2697 int i, last_non_zero; |
2698 #if 0 //variables for the outcommented version | |
2699 int code, sign, last; | |
2700 #endif | |
0 | 2701 const RLTable *rl; |
1064 | 2702 uint32_t *bits_tab; |
2703 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
|
2704 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
|
2705 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2706 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
2979 | 2707 /* mpeg4 based DC predictor */ |
2708 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
|
2709 if(last_index<1) return; |
2979 | 2710 i = 1; |
0 | 2711 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
|
2712 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
|
2713 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2714 } 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
|
2715 if(last_index<0) return; |
2979 | 2716 i = 0; |
0 | 2717 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
|
2718 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
|
2719 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2720 } |
2721 | |
2722 /* AC coefs */ | |
2723 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
|
2724 #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
|
2725 for (; i < last_index; i++) { |
2979 | 2726 int level = block[ scan_table[i] ]; |
2727 if (level) { | |
2728 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
|
2729 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
|
2730 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
|
2731 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
|
2732 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
|
2733 }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
|
2734 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
|
2735 } |
2979 | 2736 last_non_zero = i; |
2737 } | |
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
|
2738 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /*if(i<=last_index)*/{ |
2979 | 2740 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
|
2741 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
|
2742 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
|
2743 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
|
2744 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
|
2745 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
|
2746 }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
|
2747 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
|
2748 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2749 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 #else |
0 | 2751 for (; i <= last_index; i++) { |
2979 | 2752 const int slevel = block[ scan_table[i] ]; |
2753 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
|
2754 int level; |
2979 | 2755 int run = i - last_non_zero - 1; |
2756 last = (i == last_index); | |
2757 sign = 0; | |
2758 level = slevel; | |
2759 if (level < 0) { | |
2760 sign = 1; | |
2761 level = -level; | |
2762 } | |
0 | 2763 code = get_rl_index(rl, last, run, level); |
453 | 2764 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2765 if (code == rl->n) { |
2766 int level1, run1; | |
2767 level1 = level - rl->max_level[last][run]; | |
2967 | 2768 if (level1 < 1) |
0 | 2769 goto esc2; |
2770 code = get_rl_index(rl, last, run, level1); | |
2771 if (code == rl->n) { | |
2772 esc2: | |
453 | 2773 put_bits(ac_pb, 1, 1); |
0 | 2774 if (level > MAX_LEVEL) |
2775 goto esc3; | |
2776 run1 = run - rl->max_run[last][level] - 1; | |
2777 if (run1 < 0) | |
2778 goto esc3; | |
2779 code = get_rl_index(rl, last, run1, level); | |
2780 if (code == rl->n) { | |
2781 esc3: | |
2782 /* third escape */ | |
453 | 2783 put_bits(ac_pb, 1, 1); |
2784 put_bits(ac_pb, 1, last); | |
2785 put_bits(ac_pb, 6, run); | |
2786 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
|
2787 put_sbits(ac_pb, 12, slevel); |
453 | 2788 put_bits(ac_pb, 1, 1); |
0 | 2789 } else { |
2790 /* second escape */ | |
453 | 2791 put_bits(ac_pb, 1, 0); |
2792 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2793 put_bits(ac_pb, 1, sign); | |
0 | 2794 } |
2795 } else { | |
2796 /* first escape */ | |
453 | 2797 put_bits(ac_pb, 1, 0); |
2798 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2799 put_bits(ac_pb, 1, sign); | |
0 | 2800 } |
2801 } else { | |
453 | 2802 put_bits(ac_pb, 1, sign); |
0 | 2803 } |
2979 | 2804 last_non_zero = i; |
2805 } | |
0 | 2806 } |
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
|
2807 #endif |
0 | 2808 } |
936 | 2809 |
2967 | 2810 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2811 uint8_t *scan_table) |
936 | 2812 { |
2813 int i, last_non_zero; | |
1064 | 2814 uint8_t *len_tab; |
936 | 2815 const int last_index = s->block_last_index[n]; |
2816 int len=0; | |
2817 | |
2818 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2979 | 2819 /* mpeg4 based DC predictor */ |
2820 len += mpeg4_get_dc_length(intra_dc, n); | |
936 | 2821 if(last_index<1) return len; |
2979 | 2822 i = 1; |
936 | 2823 len_tab = uni_mpeg4_intra_rl_len; |
2824 } else { | |
2825 if(last_index<0) return 0; | |
2979 | 2826 i = 0; |
936 | 2827 len_tab = uni_mpeg4_inter_rl_len; |
2828 } | |
2829 | |
2830 /* AC coefs */ | |
2831 last_non_zero = i - 1; | |
2832 for (; i < last_index; i++) { | |
2979 | 2833 int level = block[ scan_table[i] ]; |
2834 if (level) { | |
2835 int run = i - last_non_zero - 1; | |
936 | 2836 level+=64; |
2837 if((level&(~127)) == 0){ | |
2838 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2839 len += len_tab[index]; | |
2840 }else{ //ESC3 | |
2841 len += 7+2+1+6+1+12+1; | |
2842 } | |
2979 | 2843 last_non_zero = i; |
2844 } | |
936 | 2845 } |
2846 /*if(i<=last_index)*/{ | |
2979 | 2847 int level = block[ scan_table[i] ]; |
936 | 2848 int run = i - last_non_zero - 1; |
2849 level+=64; | |
2850 if((level&(~127)) == 0){ | |
2851 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2852 len += len_tab[index]; | |
2853 }else{ //ESC3 | |
2854 len += 7+2+1+6+1+12+1; | |
2855 } | |
2856 } | |
2967 | 2857 |
936 | 2858 return len; |
2859 } | |
2860 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2861 #endif |
0 | 2862 |
2863 | |
2864 /***********************************************/ | |
2865 /* decoding */ | |
2866 | |
2867 static VLC intra_MCBPC_vlc; | |
2868 static VLC inter_MCBPC_vlc; | |
2869 static VLC cbpy_vlc; | |
2870 static VLC mv_vlc; | |
2871 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2872 static VLC sprite_trajectory; |
262 | 2873 static VLC mb_type_b_vlc; |
1655 | 2874 static VLC h263_mbtype_b_vlc; |
2875 static VLC cbpc_b_vlc; | |
0 | 2876 |
2877 /* init vlcs */ | |
2878 | |
2879 /* XXX: find a better solution to handle static init */ | |
2880 void h263_decode_init_vlc(MpegEncContext *s) | |
2881 { | |
2882 static int done = 0; | |
2883 | |
2884 if (!done) { | |
2885 done = 1; | |
2886 | |
7098 | 2887 INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
0 | 2888 intra_MCBPC_bits, 1, 1, |
7098 | 2889 intra_MCBPC_code, 1, 1, 72); |
2890 INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, | |
0 | 2891 inter_MCBPC_bits, 1, 1, |
7098 | 2892 inter_MCBPC_code, 1, 1, 198); |
2893 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16, | |
0 | 2894 &cbpy_tab[0][1], 2, 1, |
7098 | 2895 &cbpy_tab[0][0], 2, 1, 64); |
2896 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, | |
0 | 2897 &mvtab[0][1], 2, 1, |
7098 | 2898 &mvtab[0][0], 2, 1, 538); |
4668 | 2899 init_rl(&rl_inter, static_rl_table_store[0]); |
2900 init_rl(&rl_intra, static_rl_table_store[1]); | |
2901 init_rl(&rvlc_rl_inter, static_rl_table_store[3]); | |
2902 init_rl(&rvlc_rl_intra, static_rl_table_store[4]); | |
2903 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
|
2904 INIT_VLC_RL(rl_inter, 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2905 INIT_VLC_RL(rl_intra, 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2906 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
|
2907 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
|
2908 INIT_VLC_RL(rl_intra_aic, 554); |
7098 | 2909 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2910 &DCtab_lum[0][1], 2, 1, |
7098 | 2911 &DCtab_lum[0][0], 2, 1, 512); |
2912 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, | |
0 | 2913 &DCtab_chrom[0][1], 2, 1, |
7098 | 2914 &DCtab_chrom[0][0], 2, 1, 512); |
2915 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
|
2916 &sprite_trajectory_tab[0][1], 4, 2, |
7098 | 2917 &sprite_trajectory_tab[0][0], 4, 2, 128); |
2918 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, | |
262 | 2919 &mb_type_b_tab[0][1], 2, 1, |
7098 | 2920 &mb_type_b_tab[0][0], 2, 1, 16); |
2921 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, | |
1655 | 2922 &h263_mbtype_b_tab[0][1], 2, 1, |
7098 | 2923 &h263_mbtype_b_tab[0][0], 2, 1, 80); |
2924 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, | |
1655 | 2925 &cbpc_b_tab[0][1], 2, 1, |
7098 | 2926 &cbpc_b_tab[0][0], 2, 1, 8); |
0 | 2927 } |
2928 } | |
2929 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2930 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2931 * 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
|
2932 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2933 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
|
2934 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2935 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2936 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2937 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2938 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2939 return 4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2940 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2941 |
1661 | 2942 int ff_h263_decode_mba(MpegEncContext *s) |
2943 { | |
2944 int i, mb_pos; | |
2945 | |
2946 for(i=0; i<6; i++){ | |
1670 | 2947 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2948 } |
2949 mb_pos= get_bits(&s->gb, ff_mba_length[i]); | |
2950 s->mb_x= mb_pos % s->mb_width; | |
2951 s->mb_y= mb_pos / s->mb_width; | |
2952 | |
2953 return mb_pos; | |
2954 } | |
2955 | |
2956 void ff_h263_encode_mba(MpegEncContext *s) | |
2957 { | |
2958 int i, mb_pos; | |
2959 | |
2960 for(i=0; i<6; i++){ | |
1670 | 2961 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2962 } |
2963 mb_pos= s->mb_x + s->mb_width*s->mb_y; | |
2964 put_bits(&s->pb, ff_mba_length[i], mb_pos); | |
2965 } | |
2966 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2967 /** |
1661 | 2968 * decodes the group of blocks header or slice header. |
6524 | 2969 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2970 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2971 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 2972 { |
1661 | 2973 unsigned int val, gfid, gob_number; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2974 int left; |
2967 | 2975 |
162 | 2976 /* Check for GOB Start Code */ |
2977 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2978 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2979 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2980 |
162 | 2981 /* 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
|
2982 skip_bits(&s->gb, 16); /* Drop the zeros */ |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
9999
diff
changeset
|
2983 left= get_bits_left(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2984 //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
|
2985 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2986 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
|
2987 } |
2967 | 2988 if(left<=13) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2989 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2990 |
1661 | 2991 if(s->h263_slice_structured){ |
2992 if(get_bits1(&s->gb)==0) | |
2993 return -1; | |
2994 | |
2995 ff_h263_decode_mba(s); | |
2996 | |
2997 if(s->mb_num > 1583) | |
2998 if(get_bits1(&s->gb)==0) | |
2999 return -1; | |
2967 | 3000 |
1661 | 3001 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
3002 if(get_bits1(&s->gb)==0) | |
3003 return -1; | |
3004 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3005 }else{ | |
3006 gob_number = get_bits(&s->gb, 5); /* GN */ | |
3007 s->mb_x= 0; | |
3008 s->mb_y= s->gob_index* gob_number; | |
3009 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3010 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
3011 } | |
2967 | 3012 |
3013 if(s->mb_y >= s->mb_height) | |
1661 | 3014 return -1; |
3015 | |
2967 | 3016 if(s->qscale==0) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3017 return -1; |
1644 | 3018 |
162 | 3019 return 0; |
3020 } | |
3021 | |
290 | 3022 static inline void memsetw(short *tab, int val, int n) |
3023 { | |
3024 int i; | |
3025 for(i=0;i<n;i++) | |
3026 tab[i] = val; | |
3027 } | |
3028 | |
8590 | 3029 #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
|
3030 |
453 | 3031 void ff_mpeg4_init_partitions(MpegEncContext *s) |
3032 { | |
9431 | 3033 uint8_t *start= put_bits_ptr(&s->pb); |
1799 | 3034 uint8_t *end= s->pb.buf_end; |
3035 int size= end - start; | |
9259 | 3036 int pb_size = (((intptr_t)start + size/3)&(~3)) - (intptr_t)start; |
1912 | 3037 int tex_size= (size - 2*pb_size)&(~3); |
2967 | 3038 |
1799 | 3039 set_put_bits_buffer_size(&s->pb, pb_size); |
3040 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
|
3041 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size); |
453 | 3042 } |
3043 | |
3044 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 3045 { |
1786 | 3046 const int pb2_len = put_bits_count(&s->pb2 ); |
3047 const int tex_pb_len= put_bits_count(&s->tex_pb); | |
3048 const int bits= put_bits_count(&s->pb); | |
453 | 3049 |
6481 | 3050 if(s->pict_type==FF_I_TYPE){ |
453 | 3051 put_bits(&s->pb, 19, DC_MARKER); |
3052 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
3053 s->i_tex_bits+= tex_pb_len; | |
3054 }else{ | |
3055 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
|
3056 s->misc_bits+=17 + pb2_len; |
453 | 3057 s->mv_bits+= bits - s->last_bits; |
3058 s->p_tex_bits+= tex_pb_len; | |
3059 } | |
3060 | |
3061 flush_put_bits(&s->pb2); | |
3062 flush_put_bits(&s->tex_pb); | |
3063 | |
1799 | 3064 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf); |
3065 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len); | |
3066 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len); | |
1786 | 3067 s->last_bits= put_bits_count(&s->pb); |
453 | 3068 } |
3069 | |
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
|
3070 #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
|
3071 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3072 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
|
3073 switch(s->pict_type){ |
6481 | 3074 case FF_I_TYPE: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3075 return 16; |
6481 | 3076 case FF_P_TYPE: |
3077 case FF_S_TYPE: | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3078 return s->f_code+15; |
6481 | 3079 case FF_B_TYPE: |
6655
22cca5d3173a
Implement FFMAX3(a,b,c) - maximum over three arguments.
voroshil
parents:
6524
diff
changeset
|
3080 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
|
3081 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3082 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3083 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3084 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3085 |
8590 | 3086 #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
|
3087 |
453 | 3088 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
3089 { | |
3090 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
3091 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3092 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 3093 put_bits(&s->pb, 1, 1); |
2967 | 3094 |
453 | 3095 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
|
3096 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 3097 put_bits(&s->pb, 1, 0); /* no HEC */ |
3098 } | |
3099 | |
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
|
3100 #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
|
3101 |
453 | 3102 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3103 * 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
|
3104 * @return 0 if not |
453 | 3105 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3106 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
|
3107 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
|
3108 int v= show_bits(&s->gb, 16); |
2967 | 3109 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3110 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
|
3111 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3112 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3113 |
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
|
3114 while(v<=0xFF){ |
6481 | 3115 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
|
3116 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
|
3117 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
|
3118 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
|
3119 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
|
3120 } |
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
|
3121 |
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
|
3122 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
|
3123 v>>=8; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3124 v|= 0x7F >> (7-(bits_count&7)); |
2967 | 3125 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3126 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3127 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3128 }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
|
3129 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
|
3130 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3131 GetBitContext gb= s->gb; |
2967 | 3132 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3133 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3134 align_get_bits(&s->gb); |
2967 | 3135 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3136 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3137 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3138 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3139 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3140 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3141 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3142 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
|
3143 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3144 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3145 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3146 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3147 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3148 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3149 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3150 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3151 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3152 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3153 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 3154 { |
290 | 3155 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
|
3156 int header_extension=0, mb_num, len; |
2967 | 3157 |
453 | 3158 /* 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
|
3159 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
|
3160 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3161 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3162 if(get_bits1(&s->gb)) break; |
453 | 3163 } |
3164 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3165 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
|
3166 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); |
453 | 3167 return -1; |
3168 } | |
2967 | 3169 |
453 | 3170 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3171 header_extension= get_bits1(&s->gb); |
453 | 3172 //FIXME more stuff here |
3173 } | |
3174 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3175 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
|
3176 if(mb_num>=s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3177 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 3178 return -1; |
3179 } | |
6481 | 3180 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
|
3181 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
6497 | 3182 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded |
1176 | 3183 } |
2967 | 3184 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3185 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
|
3186 s->mb_y= mb_num / s->mb_width; |
453 | 3187 |
3188 if(s->shape != BIN_ONLY_SHAPE){ | |
2967 | 3189 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
|
3190 if(qscale) |
1644 | 3191 s->chroma_qscale=s->qscale= qscale; |
290 | 3192 } |
3193 | |
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); |
290 | 3196 } |
3197 if(header_extension){ | |
453 | 3198 int time_increment; |
290 | 3199 int time_incr=0; |
453 | 3200 |
2967 | 3201 while (get_bits1(&s->gb) != 0) |
290 | 3202 time_incr++; |
3203 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3204 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
|
3205 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
|
3206 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
2967 | 3207 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3208 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 3209 //FIXME not rect stuff here |
3210 | |
3211 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3212 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
|
3213 //FIXME don't just ignore everything |
6481 | 3214 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1914 | 3215 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
|
3216 av_log(s->avctx, AV_LOG_ERROR, "untested\n"); |
290 | 3217 } |
3218 | |
3219 //FIXME reduced res stuff here | |
2967 | 3220 |
6481 | 3221 if (s->pict_type != FF_I_TYPE) { |
2979 | 3222 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 3223 if(f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3224 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); |
290 | 3225 } |
3226 } | |
6481 | 3227 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
|
3228 int b_code = get_bits(&s->gb, 3); |
660 | 3229 if(b_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3230 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); |
660 | 3231 } |
2967 | 3232 } |
290 | 3233 } |
3234 } | |
3235 //FIXME new-pred stuff | |
2967 | 3236 |
453 | 3237 //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)); |
3238 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3239 return 0; |
453 | 3240 } |
3241 | |
3242 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
3243 { | |
3244 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 3245 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3246 l_wrap= s->b8_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3247 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
|
3248 c_wrap= s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3249 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1; |
290 | 3250 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3251 #if 0 |
290 | 3252 /* clean DC */ |
453 | 3253 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
3254 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
3255 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
|
3256 #endif |
290 | 3257 |
3258 /* clean AC */ | |
1064 | 3259 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
3260 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
3261 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 3262 |
3263 /* clean MV */ | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
3264 // we can't clear the MVs as they might be needed by a b frame |
1064 | 3265 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
3266 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 3267 s->last_mv[0][0][0]= |
3268 s->last_mv[0][0][1]= | |
3269 s->last_mv[1][0][0]= | |
3270 s->last_mv[1][0][1]= 0; | |
3271 } | |
3272 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3273 /** |
9024
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3274 * finds the next resync_marker |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3275 * @param p pointer to buffer to scan |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3276 * @param end pointer to the end of the buffer |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3277 * @return pointer to the next resync_marker, or \p end if none was found |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3278 */ |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3279 const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end) |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3280 { |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3281 assert(p < end); |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3282 |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3283 end-=2; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3284 p++; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3285 for(;p<end; p+=2){ |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3286 if(!*p){ |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3287 if (!p[-1] && p[1]) return p - 1; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3288 else if(!p[ 1] && p[2]) return p; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3289 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3290 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3291 return end+2; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3292 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3293 |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3294 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3295 * 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
|
3296 * @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
|
3297 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3298 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
|
3299 int left, pos, ret; |
2967 | 3300 |
1521 | 3301 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
|
3302 skip_bits1(&s->gb); |
1521 | 3303 align_get_bits(&s->gb); |
3304 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3305 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3306 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
|
3307 pos= get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3308 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3309 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3310 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3311 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3312 if(ret>=0) |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3313 return pos; |
453 | 3314 } |
5129 | 3315 //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
|
3316 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3317 align_get_bits(&s->gb); |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
9999
diff
changeset
|
3318 left= get_bits_left(&s->gb); |
2967 | 3319 |
3320 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
|
3321 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3322 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3323 |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3324 pos= get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3325 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3326 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3327 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3328 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3329 if(ret>=0) |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3330 return pos; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3331 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3332 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3333 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3334 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3335 } |
2967 | 3336 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3337 return -1; |
453 | 3338 } |
3339 | |
3340 /** | |
1034 | 3341 * gets the average motion vector for a GMC MB. |
753 | 3342 * @param n either 0 for the x component or 1 for y |
3343 * @returns the average MV for a GMC MB | |
3344 */ | |
3345 static inline int get_amv(MpegEncContext *s, int n){ | |
3346 int x, y, mb_v, sum, dx, dy, shift; | |
3347 int len = 1 << (s->f_code + 4); | |
3348 const int a= s->sprite_warping_accuracy; | |
2967 | 3349 |
1997 | 3350 if(s->workaround_bugs & FF_BUG_AMV) |
3351 len >>= s->quarter_sample; | |
753 | 3352 |
3353 if(s->real_sprite_warping_points==1){ | |
3354 if(s->divx_version==500 && s->divx_build==413) | |
3355 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
3356 else | |
3357 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
3358 }else{ | |
3359 dx= s->sprite_delta[n][0]; | |
3360 dy= s->sprite_delta[n][1]; | |
3361 shift= s->sprite_shift[0]; | |
3362 if(n) dy -= 1<<(shift + a + 1); | |
3363 else dx -= 1<<(shift + a + 1); | |
3364 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
3365 | |
3366 sum=0; | |
3367 for(y=0; y<16; y++){ | |
3368 int v; | |
2967 | 3369 |
753 | 3370 v= mb_v + dy*y; |
3371 //XXX FIXME optimize | |
3372 for(x=0; x<16; x++){ | |
3373 sum+= v>>shift; | |
3374 v+= dx; | |
3375 } | |
3376 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
3377 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 3378 } |
3379 | |
3380 if (sum < -len) sum= -len; | |
3381 else if (sum >= len) sum= len-1; | |
3382 | |
3383 return sum; | |
3384 } | |
3385 | |
3386 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3387 * decodes first partition. |
6524 | 3388 * @return number of MBs decoded or <0 if an error occurred |
453 | 3389 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3390 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
|
3391 int mb_num; |
1064 | 3392 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
2967 | 3393 |
453 | 3394 /* decode first partition */ |
3395 mb_num=0; | |
290 | 3396 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3397 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
|
3398 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3399 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
|
3400 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3401 int cbpc; |
3402 int dir=0; | |
2967 | 3403 |
453 | 3404 mb_num++; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3405 ff_update_block_index(s); |
453 | 3406 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
3407 s->first_slice_line=0; | |
2967 | 3408 |
6481 | 3409 if(s->pict_type==FF_I_TYPE){ |
453 | 3410 int i; |
3411 | |
1482 | 3412 do{ |
1873 | 3413 if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
3414 return mb_num-1; | |
3415 } | |
3416 | |
1482 | 3417 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
3418 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3419 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
1482 | 3420 return -1; |
3421 } | |
3422 }while(cbpc == 8); | |
2967 | 3423 |
453 | 3424 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
|
3425 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3426 s->mb_intra = 1; |
3427 | |
3428 if(cbpc & 4) { | |
1652 | 3429 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3430 } |
903 | 3431 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3432 |
3433 s->mbintra_table[xy]= 1; | |
3434 for(i=0; i<6; i++){ | |
3435 int dc_pred_dir; | |
2967 | 3436 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3437 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3438 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
|
3439 return -1; |
453 | 3440 } |
3441 dir<<=1; | |
3442 if(dc_pred_dir) dir|=1; | |
3443 } | |
3444 s->pred_dir_table[xy]= dir; | |
3445 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3446 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
|
3447 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
|
3448 const int stride= s->b8_stride*2; |
453 | 3449 |
1873 | 3450 try_again: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3451 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3452 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3453 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3454 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3455 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3456 if(bits&0x10000){ |
453 | 3457 /* skip mb */ |
6481 | 3458 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
|
3459 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 3460 mx= get_amv(s, 0); |
3461 my= get_amv(s, 1); | |
453 | 3462 }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
|
3463 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3464 mx=my=0; |
453 | 3465 } |
3466 mot_val[0 ]= mot_val[2 ]= | |
3467 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3468 mot_val[1 ]= mot_val[3 ]= | |
3469 mot_val[1+stride]= mot_val[3+stride]= my; | |
3470 | |
3471 if(s->mbintra_table[xy]) | |
3472 ff_clean_intra_table_entries(s); | |
3473 continue; | |
3474 } | |
1482 | 3475 |
544 | 3476 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 3477 if (cbpc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3478 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
|
3479 return -1; |
453 | 3480 } |
1873 | 3481 if(cbpc == 20) |
3482 goto try_again; | |
1482 | 3483 |
453 | 3484 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
2967 | 3485 |
453 | 3486 s->mb_intra = ((cbpc & 4) != 0); |
2967 | 3487 |
453 | 3488 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
|
3489 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3490 s->mbintra_table[xy]= 1; |
2967 | 3491 mot_val[0 ]= mot_val[2 ]= |
453 | 3492 mot_val[0+stride]= mot_val[2+stride]= 0; |
3493 mot_val[1 ]= mot_val[3 ]= | |
3494 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3495 }else{ | |
3496 if(s->mbintra_table[xy]) | |
3497 ff_clean_intra_table_entries(s); | |
3498 | |
6481 | 3499 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
453 | 3500 s->mcsel= get_bits1(&s->gb); |
3501 else s->mcsel= 0; | |
2967 | 3502 |
453 | 3503 if ((cbpc & 16) == 0) { |
3504 /* 16x16 motion prediction */ | |
3505 | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3506 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
753 | 3507 if(!s->mcsel){ |
3508 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3509 if (mx >= 0xffff) | |
3510 return -1; | |
3511 | |
3512 my = h263_decode_motion(s, pred_y, s->f_code); | |
3513 if (my >= 0xffff) | |
3514 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
|
3515 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3516 } else { |
3517 mx = get_amv(s, 0); | |
3518 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
|
3519 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 3520 } |
753 | 3521 |
453 | 3522 mot_val[0 ]= mot_val[2 ] = |
3523 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3524 mot_val[1 ]= mot_val[3 ]= | |
3525 mot_val[1+stride]= mot_val[3+stride]= my; | |
3526 } else { | |
3527 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
|
3528 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 3529 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
|
3530 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
453 | 3531 mx = h263_decode_motion(s, pred_x, s->f_code); |
3532 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3533 return -1; |
2967 | 3534 |
453 | 3535 my = h263_decode_motion(s, pred_y, s->f_code); |
3536 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3537 return -1; |
453 | 3538 mot_val[0] = mx; |
3539 mot_val[1] = my; | |
3540 } | |
3541 } | |
3542 } | |
3543 } | |
3544 } | |
3545 s->mb_x= 0; | |
3546 } | |
3547 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3548 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3549 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3550 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3551 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3552 * decode second partition. |
6524 | 3553 * @return <0 if an error occurred |
745
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 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
|
3556 int mb_num=0; |
1064 | 3557 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
|
3558 |
453 | 3559 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
|
3560 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3561 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
|
3562 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3563 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
|
3564 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3565 |
3566 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3567 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3568 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
|
3569 s->first_slice_line=0; |
2967 | 3570 |
6481 | 3571 if(s->pict_type==FF_I_TYPE){ |
453 | 3572 int ac_pred= get_bits1(&s->gb); |
544 | 3573 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3574 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3575 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
|
3576 return -1; |
453 | 3577 } |
2967 | 3578 |
453 | 3579 s->cbp_table[xy]|= cbpy<<2; |
2967 | 3580 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 3581 }else{ /* P || S_TYPE */ |
2967 | 3582 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 3583 int dir=0,i; |
3584 int ac_pred = get_bits1(&s->gb); | |
544 | 3585 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3586 |
3587 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3588 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
|
3589 return -1; |
453 | 3590 } |
2967 | 3591 |
453 | 3592 if(s->cbp_table[xy] & 8) { |
1652 | 3593 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3594 } |
903 | 3595 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3596 |
3597 for(i=0; i<6; i++){ | |
3598 int dc_pred_dir; | |
2967 | 3599 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3600 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3601 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
|
3602 return -1; |
453 | 3603 } |
3604 dir<<=1; | |
3605 if(dc_pred_dir) dir|=1; | |
3606 } | |
3607 s->cbp_table[xy]&= 3; //remove dquant | |
3608 s->cbp_table[xy]|= cbpy<<2; | |
2967 | 3609 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
|
3610 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
|
3611 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 3612 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3613 s->cbp_table[xy]= 0; |
3614 }else{ | |
544 | 3615 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3616 |
3617 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3618 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
|
3619 return -1; |
453 | 3620 } |
2967 | 3621 |
453 | 3622 if(s->cbp_table[xy] & 8) { |
1652 | 3623 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3624 } |
903 | 3625 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3626 |
3627 s->cbp_table[xy]&= 3; //remove dquant | |
3628 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3629 } | |
3630 } | |
3631 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3632 if(mb_num >= mb_count) return 0; |
453 | 3633 s->mb_x= 0; |
3634 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3635 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3636 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3637 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3638 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3639 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3640 * @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
|
3641 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3642 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3643 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3644 int mb_num; |
6481 | 3645 const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
3646 const int part_a_end = s->pict_type==FF_I_TYPE ? (DC_END |MV_END) : MV_END; | |
2967 | 3647 |
3648 mb_num= mpeg4_decode_partition_a(s); | |
1144 | 3649 if(mb_num<0){ |
3650 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
|
3651 return -1; |
1144 | 3652 } |
2967 | 3653 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3654 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
|
3655 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); |
1144 | 3656 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
|
3657 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3658 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3659 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3660 s->mb_num_left= mb_num; |
2967 | 3661 |
6481 | 3662 if(s->pict_type==FF_I_TYPE){ |
1873 | 3663 while(show_bits(&s->gb, 9) == 1) |
3664 skip_bits(&s->gb, 9); | |
1257 | 3665 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
|
3666 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
|
3667 return -1; |
1144 | 3668 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3669 }else{ |
1873 | 3670 while(show_bits(&s->gb, 10) == 1) |
3671 skip_bits(&s->gb, 10); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3672 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
|
3673 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
|
3674 return -1; |
1144 | 3675 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3676 } |
1144 | 3677 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); |
2967 | 3678 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3679 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
6481 | 3680 if(s->pict_type==FF_P_TYPE) |
1144 | 3681 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
|
3682 return -1; |
1144 | 3683 }else{ |
6481 | 3684 if(s->pict_type==FF_P_TYPE) |
1144 | 3685 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
|
3686 } |
453 | 3687 |
2967 | 3688 return 0; |
453 | 3689 } |
3690 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3691 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3692 * decode partition C of one MB. |
6524 | 3693 * @return <0 if an error occurred |
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 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 3696 { |
3697 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
|
3698 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
|
3699 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3700 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
|
3701 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3702 |
3282 | 3703 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; |
3704 | |
903 | 3705 if(s->current_picture.qscale_table[xy] != s->qscale){ |
1652 | 3706 ff_set_qscale(s, s->current_picture.qscale_table[xy] ); |
453 | 3707 } |
2967 | 3708 |
6481 | 3709 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { |
453 | 3710 int i; |
3711 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
|
3712 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
|
3713 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
453 | 3714 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3715 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
|
3716 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
3717 if (IS_SKIP(mb_type)) { |
453 | 3718 /* skip mb */ |
3719 for(i=0;i<6;i++) | |
3720 s->block_last_index[i] = -1; | |
3721 s->mv_dir = MV_DIR_FORWARD; | |
3722 s->mv_type = MV_TYPE_16X16; | |
6481 | 3723 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
453 | 3724 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
|
3725 s->mb_skipped = 0; |
453 | 3726 }else{ |
3727 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
|
3728 s->mb_skipped = 1; |
453 | 3729 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3730 }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
|
3731 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3732 }else if(!s->mb_intra){ |
3733 // s->mcsel= 0; //FIXME do we need to init that | |
2967 | 3734 |
453 | 3735 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
|
3736 if (IS_8X8(mb_type)) { |
453 | 3737 s->mv_type = MV_TYPE_8X8; |
3738 } else { | |
3739 s->mv_type = MV_TYPE_16X16; | |
3740 } | |
3741 } | |
3742 } else { /* I-Frame */ | |
3743 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
|
3744 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3745 } |
3746 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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 if (!IS_SKIP(mb_type)) { |
1132 | 3748 int i; |
2632 | 3749 s->dsp.clear_blocks(s->block[0]); |
453 | 3750 /* decode each block */ |
3751 for (i = 0; i < 6; i++) { | |
1132 | 3752 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
|
3753 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); |
453 | 3754 return -1; |
3755 } | |
718 | 3756 cbp+=cbp; |
453 | 3757 } |
3758 } | |
290 | 3759 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3760 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3761 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3762 if(--s->mb_num_left <= 0){ |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
9999
diff
changeset
|
3763 //printf("%06X %d\n", show_bits(&s->gb, 24), get_bits_left(&s->gb)); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3764 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3765 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3766 else |
2967 | 3767 return SLICE_NOEND; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3768 }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
|
3769 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
|
3770 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
|
3771 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
|
3772 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
|
3773 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3775 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3776 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3777 |
1633 | 3778 /** |
3779 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
3780 */ | |
3781 static void preview_obmc(MpegEncContext *s){ | |
3782 GetBitContext gb= s->gb; | |
2967 | 3783 |
1633 | 3784 int cbpc, i, pred_x, pred_y, mx, my; |
3785 int16_t *mot_val; | |
3786 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
|
3787 const int stride= s->b8_stride*2; |
2967 | 3788 |
1633 | 3789 for(i=0; i<4; i++) |
3790 s->block_index[i]+= 2; | |
3791 for(i=4; i<6; i++) | |
3792 s->block_index[i]+= 1; | |
3793 s->mb_x++; | |
2967 | 3794 |
6481 | 3795 assert(s->pict_type == FF_P_TYPE); |
1633 | 3796 |
3797 do{ | |
3798 if (get_bits1(&s->gb)) { | |
3799 /* 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
|
3800 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; |
2967 | 3801 mot_val[0 ]= mot_val[2 ]= |
1633 | 3802 mot_val[0+stride]= mot_val[2+stride]= 0; |
3803 mot_val[1 ]= mot_val[3 ]= | |
3804 mot_val[1+stride]= mot_val[3+stride]= 0; | |
2967 | 3805 |
1633 | 3806 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
3807 goto end; | |
3808 } | |
3809 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
3810 }while(cbpc == 20); | |
2967 | 3811 |
1633 | 3812 if(cbpc & 4){ |
3813 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
3814 }else{ | |
3815 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3816 if (cbpc & 8) { | |
1656 | 3817 if(s->modified_quant){ |
3818 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
3819 else skip_bits(&s->gb, 5); | |
3820 }else | |
3821 skip_bits(&s->gb, 2); | |
1633 | 3822 } |
2967 | 3823 |
1633 | 3824 if ((cbpc & 16) == 0) { |
2967 | 3825 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
1633 | 3826 /* 16x16 motion prediction */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3827 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1633 | 3828 if (s->umvplus) |
3829 mx = h263p_decode_umotion(s, pred_x); | |
3830 else | |
1655 | 3831 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3832 |
1633 | 3833 if (s->umvplus) |
3834 my = h263p_decode_umotion(s, pred_y); | |
3835 else | |
1655 | 3836 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3837 |
3838 mot_val[0 ]= mot_val[2 ]= | |
1633 | 3839 mot_val[0+stride]= mot_val[2+stride]= mx; |
3840 mot_val[1 ]= mot_val[3 ]= | |
3841 mot_val[1+stride]= mot_val[3+stride]= my; | |
3842 } else { | |
2967 | 3843 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
1633 | 3844 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
|
3845 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 3846 if (s->umvplus) |
3847 mx = h263p_decode_umotion(s, pred_x); | |
3848 else | |
1655 | 3849 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3850 |
1633 | 3851 if (s->umvplus) |
3852 my = h263p_decode_umotion(s, pred_y); | |
2967 | 3853 else |
1655 | 3854 my = h263_decode_motion(s, pred_y, 1); |
1633 | 3855 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
3856 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
3857 mot_val[0] = mx; | |
3858 mot_val[1] = my; | |
3859 } | |
3860 } | |
3861 } | |
3862 end: | |
2967 | 3863 |
1633 | 3864 for(i=0; i<4; i++) |
3865 s->block_index[i]-= 2; | |
3866 for(i=4; i<6; i++) | |
3867 s->block_index[i]-= 1; | |
3868 s->mb_x--; | |
3869 | |
3870 s->gb= gb; | |
3871 } | |
3872 | |
1656 | 3873 static void h263_decode_dquant(MpegEncContext *s){ |
3874 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
3875 | |
3876 if(s->modified_quant){ | |
3877 if(get_bits1(&s->gb)) | |
3878 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; | |
3879 else | |
3880 s->qscale= get_bits(&s->gb, 5); | |
3881 }else | |
3882 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
3883 ff_set_qscale(s, s->qscale); | |
3884 } | |
3885 | |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3886 static int h263_skip_b_part(MpegEncContext *s, int cbp) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3887 { |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3888 DECLARE_ALIGNED(16, DCTELEM, dblock[64]); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3889 int i, mbi; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3890 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3891 /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3892 * but real value should be restored in order to be used later (in OBMC condition) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3893 */ |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3894 mbi = s->mb_intra; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3895 s->mb_intra = 0; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3896 for (i = 0; i < 6; i++) { |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3897 if (h263_decode_block(s, dblock, i, cbp&32) < 0) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3898 return -1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3899 cbp+=cbp; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3900 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3901 s->mb_intra = mbi; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3902 return 0; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3903 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3904 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3905 static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3906 { |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3907 int c, mv = 1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3908 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3909 if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3910 c = get_bits1(gb); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3911 if (pb_frame == 2 && c) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3912 mv = !get_bits1(gb); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3913 } else { // h.263 Annex M improved PB-frame |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3914 mv = get_unary(gb, 0, 4) + 1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3915 c = mv & 1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3916 mv = !!(mv & 2); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3917 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3918 if(c) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3919 *cbpb = get_bits(gb, 6); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3920 return mv; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3921 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3922 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3923 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3924 DCTELEM block[6][64]) |
0 | 3925 { |
3926 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3927 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
|
3928 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3929 int cbpb = 0, pb_mv_count = 0; |
2967 | 3930 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3931 assert(!s->h263_pred); |
2967 | 3932 |
6481 | 3933 if (s->pict_type == FF_P_TYPE) { |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3934 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3935 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3936 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3937 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3938 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3939 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3940 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3941 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
|
3942 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3943 s->mv[0][0][0] = 0; |
3944 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
|
3945 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
|
3946 goto end; |
255 | 3947 } |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3948 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
|
3949 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3950 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3951 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
|
3952 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3953 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3954 }while(cbpc == 20); |
2967 | 3955 |
2632 | 3956 s->dsp.clear_blocks(s->block[0]); |
2967 | 3957 |
0 | 3958 dquant = cbpc & 8; |
3959 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3960 if (s->mb_intra) goto intra; |
2967 | 3961 |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3962 if(s->pb_frame && get_bits1(&s->gb)) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3963 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
544 | 3964 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2967 | 3965 |
1637 | 3966 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
3967 cbpy ^= 0xF; | |
2967 | 3968 |
1637 | 3969 cbp = (cbpc & 3) | (cbpy << 2); |
0 | 3970 if (dquant) { |
1656 | 3971 h263_decode_dquant(s); |
0 | 3972 } |
2967 | 3973 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3974 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3975 if ((cbpc & 16) == 0) { |
2967 | 3976 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
|
3977 /* 16x16 motion prediction */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3978 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
|
3979 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
|
3980 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3981 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3982 else |
1655 | 3983 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3984 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3985 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3986 return -1; |
2967 | 3987 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3988 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3989 my = h263p_decode_umotion(s, pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3990 else |
1655 | 3991 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3992 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3993 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3994 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3995 s->mv[0][0][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3996 s->mv[0][0][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3997 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3998 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
2967 | 3999 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
|
4000 } else { |
2967 | 4001 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
|
4002 s->mv_type = MV_TYPE_8X8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4003 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
|
4004 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
|
4005 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4006 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4007 else |
1655 | 4008 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
|
4009 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4010 return -1; |
2967 | 4011 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4012 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4013 my = h263p_decode_umotion(s, pred_y); |
2967 | 4014 else |
1655 | 4015 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
|
4016 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4017 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4018 s->mv[0][i][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4019 s->mv[0][i][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4020 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
|
4021 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
|
4022 mot_val[0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4023 mot_val[1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4024 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4025 } |
6481 | 4026 } else if(s->pict_type==FF_B_TYPE) { |
1655 | 4027 int mb_type; |
4028 const int stride= s->b8_stride; | |
1701 | 4029 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; |
4030 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; | |
1655 | 4031 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; |
4032 | |
2967 | 4033 //FIXME ugly |
4034 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= | |
4035 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= | |
4036 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= | |
1701 | 4037 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; |
1655 | 4038 |
4039 do{ | |
4040 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
4041 if (mb_type < 0){ | |
4042 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
4043 return -1; | |
4044 } | |
4045 | |
4046 mb_type= h263_mb_type_b_map[ mb_type ]; | |
4047 }while(!mb_type); | |
4048 | |
4049 s->mb_intra = IS_INTRA(mb_type); | |
4050 if(HAS_CBP(mb_type)){ | |
2632 | 4051 s->dsp.clear_blocks(s->block[0]); |
1655 | 4052 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); |
4053 if(s->mb_intra){ | |
4054 dquant = IS_QUANT(mb_type); | |
4055 goto intra; | |
4056 } | |
4057 | |
4058 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
4059 | |
4060 if (cbpy < 0){ | |
4061 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
4062 return -1; | |
4063 } | |
2967 | 4064 |
1655 | 4065 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
4066 cbpy ^= 0xF; | |
2967 | 4067 |
1655 | 4068 cbp = (cbpc & 3) | (cbpy << 2); |
4069 }else | |
4070 cbp=0; | |
2967 | 4071 |
1655 | 4072 assert(!s->mb_intra); |
4073 | |
4074 if(IS_QUANT(mb_type)){ | |
1656 | 4075 h263_decode_dquant(s); |
1655 | 4076 } |
4077 | |
4078 if(IS_DIRECT(mb_type)){ | |
4079 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
4080 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); | |
4081 }else{ | |
4082 s->mv_dir = 0; | |
4083 s->mv_type= MV_TYPE_16X16; | |
4084 //FIXME UMV | |
4085 | |
4086 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
|
4087 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); |
1655 | 4088 s->mv_dir = MV_DIR_FORWARD; |
4089 | |
4090 mx = h263_decode_motion(s, mx, 1); | |
4091 my = h263_decode_motion(s, my, 1); | |
2967 | 4092 |
1655 | 4093 s->mv[0][0][0] = mx; |
4094 s->mv[0][0][1] = my; | |
1701 | 4095 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4096 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4097 } |
2967 | 4098 |
1655 | 4099 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
|
4100 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); |
1655 | 4101 s->mv_dir |= MV_DIR_BACKWARD; |
2967 | 4102 |
1655 | 4103 mx = h263_decode_motion(s, mx, 1); |
4104 my = h263_decode_motion(s, my, 1); | |
1701 | 4105 |
1655 | 4106 s->mv[1][0][0] = mx; |
4107 s->mv[1][0][1] = my; | |
1701 | 4108 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4109 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4110 } |
4111 } | |
2967 | 4112 |
1655 | 4113 s->current_picture.mb_type[xy]= mb_type; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4114 } else { /* I-Frame */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4115 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4116 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
|
4117 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4118 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
|
4119 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4120 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4121 }while(cbpc == 8); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4122 |
2632 | 4123 s->dsp.clear_blocks(s->block[0]); |
4124 | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4125 dquant = cbpc & 4; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4126 s->mb_intra = 1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4127 intra: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4128 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
|
4129 if (s->h263_aic) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4130 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4131 if(s->ac_pred){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4132 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
2967 | 4133 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4134 s->h263_aic_dir = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4135 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4136 }else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4137 s->ac_pred = 0; |
2967 | 4138 |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4139 if(s->pb_frame && get_bits1(&s->gb)) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4140 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4141 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
|
4142 if(cbpy<0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4143 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
|
4144 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4145 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4146 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4147 if (dquant) { |
1656 | 4148 h263_decode_dquant(s); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4149 } |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4150 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4151 pb_mv_count += !!s->pb_frame; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4152 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4153 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4154 while(pb_mv_count--){ |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4155 h263_decode_motion(s, 0, 1); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4156 h263_decode_motion(s, 0, 1); |
9093 | 4157 } |
4158 | |
4159 /* decode each block */ | |
4160 for (i = 0; i < 6; i++) { | |
4161 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
4162 return -1; | |
4163 cbp+=cbp; | |
4164 } | |
4165 | |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4166 if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4167 return -1; |
9093 | 4168 if(s->obmc && !s->mb_intra){ |
4169 if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1) | |
4170 preview_obmc(s); | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4171 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4172 end: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4173 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4174 /* per-MB end of slice check */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4175 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4176 int v= show_bits(&s->gb, 16); |
2967 | 4177 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4178 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
|
4179 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
|
4180 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4181 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4182 if(v==0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4183 return SLICE_END; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4184 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4185 |
2967 | 4186 return SLICE_OK; |
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 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4189 int ff_mpeg4_decode_mb(MpegEncContext *s, |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4190 DCTELEM block[6][64]) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4191 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4192 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
|
4193 int16_t *mot_val; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4194 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
|
4195 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
2967 | 4196 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4197 assert(s->h263_pred); |
2967 | 4198 |
6481 | 4199 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
|
4200 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4201 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4202 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4203 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4204 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4205 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4206 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4207 s->mv_type = MV_TYPE_16X16; |
6481 | 4208 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
|
4209 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
|
4210 s->mcsel=1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4211 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
|
4212 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
|
4213 |
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
|
4214 s->mb_skipped = 0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4215 }else{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4216 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
|
4217 s->mcsel=0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4218 s->mv[0][0][0] = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4219 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
|
4220 s->mb_skipped = 1; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4221 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4222 goto end; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4223 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4224 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
|
4225 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4226 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4227 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
|
4228 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4229 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4230 }while(cbpc == 20); |
2967 | 4231 |
2632 | 4232 s->dsp.clear_blocks(s->block[0]); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4233 dquant = cbpc & 8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4234 s->mb_intra = ((cbpc & 4) != 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4235 if (s->mb_intra) goto intra; |
2967 | 4236 |
6481 | 4237 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
|
4238 s->mcsel= get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4239 else s->mcsel= 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4240 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; |
2967 | 4241 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4242 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4243 if (dquant) { |
1652 | 4244 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
|
4245 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4246 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
|
4247 s->interlaced_dct= get_bits1(&s->gb); |
2967 | 4248 |
0 | 4249 s->mv_dir = MV_DIR_FORWARD; |
4250 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4251 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
|
4252 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
|
4253 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4254 s->mv_type = MV_TYPE_16X16; |
753 | 4255 mx= get_amv(s, 0); |
4256 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
|
4257 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
|
4258 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
|
4259 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
2967 | 4260 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
|
4261 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4262 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
|
4263 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4264 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
|
4265 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
|
4266 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4267 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 4268 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4269 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
|
4270 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
|
4271 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4272 return -1; |
2967 | 4273 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4274 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
|
4275 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4276 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4277 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4278 s->mv[0][i][0] = mx; |
661 | 4279 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
|
4280 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4281 }else{ |
2967 | 4282 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
|
4283 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4284 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
|
4285 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
|
4286 mx = h263_decode_motion(s, pred_x, s->f_code); |
2967 | 4287 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4288 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4289 return -1; |
2967 | 4290 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4291 my = h263_decode_motion(s, pred_y, s->f_code); |
2967 | 4292 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4293 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4294 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4295 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
|
4296 s->mv[0][0][1] = my; |
255 | 4297 } |
0 | 4298 } else { |
2967 | 4299 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 4300 s->mv_type = MV_TYPE_8X8; |
4301 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
|
4302 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
|
4303 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 4304 if (mx >= 0xffff) |
4305 return -1; | |
2967 | 4306 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4307 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 4308 if (my >= 0xffff) |
4309 return -1; | |
4310 s->mv[0][i][0] = mx; | |
4311 s->mv[0][i][1] = my; | |
4312 mot_val[0] = mx; | |
4313 mot_val[1] = my; | |
4314 } | |
4315 } | |
6481 | 4316 } else if(s->pict_type==FF_B_TYPE) { |
262 | 4317 int modb1; // first bit of modb |
4318 int modb2; // second bit of modb | |
4319 int mb_type; | |
4320 | |
4321 s->mb_intra = 0; //B-frames never contain intra blocks | |
4322 s->mcsel=0; // ... true gmc blocks | |
4323 | |
4324 if(s->mb_x==0){ | |
674 | 4325 for(i=0; i<2; i++){ |
2967 | 4326 s->last_mv[i][0][0]= |
4327 s->last_mv[i][0][1]= | |
4328 s->last_mv[i][1][0]= | |
674 | 4329 s->last_mv[i][1][1]= 0; |
4330 } | |
262 | 4331 } |
4332 | |
4333 /* 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
|
4334 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
|
4335 |
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
|
4336 if(s->mb_skipped){ |
262 | 4337 /* skip mb */ |
4338 for(i=0;i<6;i++) | |
4339 s->block_last_index[i] = -1; | |
4340 | |
4341 s->mv_dir = MV_DIR_FORWARD; | |
4342 s->mv_type = MV_TYPE_16X16; | |
4343 s->mv[0][0][0] = 0; | |
4344 s->mv[0][0][1] = 0; | |
4345 s->mv[1][0][0] = 0; | |
4346 s->mv[1][0][1] = 0; | |
2967 | 4347 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
|
4348 goto end; |
262 | 4349 } |
4350 | |
2967 | 4351 modb1= get_bits1(&s->gb); |
666 | 4352 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
|
4353 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 4354 cbp=0; |
4355 }else{ | |
262 | 4356 modb2= get_bits1(&s->gb); |
544 | 4357 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
|
4358 if(mb_type<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4359 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
|
4360 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
|
4361 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4362 mb_type= mb_type_b_map[ mb_type ]; |
666 | 4363 if(modb2) cbp= 0; |
2632 | 4364 else{ |
4365 s->dsp.clear_blocks(s->block[0]); | |
4366 cbp= get_bits(&s->gb, 6); | |
4367 } | |
666 | 4368 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4369 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 4370 if(get_bits1(&s->gb)){ |
1652 | 4371 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); |
262 | 4372 } |
4373 } | |
664 | 4374 |
4375 if(!s->progressive_sequence){ | |
4376 if(cbp) | |
4377 s->interlaced_dct= get_bits1(&s->gb); | |
4378 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4379 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
|
4380 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
|
4381 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
|
4382 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4383 if(USES_LIST(mb_type, 0)){ |
667 | 4384 s->field_select[0][0]= get_bits1(&s->gb); |
4385 s->field_select[0][1]= get_bits1(&s->gb); | |
4386 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4387 if(USES_LIST(mb_type, 1)){ |
667 | 4388 s->field_select[1][0]= get_bits1(&s->gb); |
4389 s->field_select[1][1]= get_bits1(&s->gb); | |
4390 } | |
4391 } | |
666 | 4392 } |
4393 | |
667 | 4394 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
|
4395 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 4396 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
|
4397 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4398 if(USES_LIST(mb_type, 0)){ |
666 | 4399 s->mv_dir = MV_DIR_FORWARD; |
4400 | |
4401 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
4402 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
4403 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
4404 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 4405 } |
2967 | 4406 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4407 if(USES_LIST(mb_type, 1)){ |
666 | 4408 s->mv_dir |= MV_DIR_BACKWARD; |
4409 | |
4410 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
4411 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
4412 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
4413 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
4414 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4415 }else if(!IS_DIRECT(mb_type)){ |
666 | 4416 s->mv_type= MV_TYPE_FIELD; |
667 | 4417 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4418 if(USES_LIST(mb_type, 0)){ |
666 | 4419 s->mv_dir = MV_DIR_FORWARD; |
2967 | 4420 |
666 | 4421 for(i=0; i<2; i++){ |
4422 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
4423 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
4424 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
4425 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
4426 } | |
667 | 4427 } |
2967 | 4428 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4429 if(USES_LIST(mb_type, 1)){ |
666 | 4430 s->mv_dir |= MV_DIR_BACKWARD; |
4431 | |
4432 for(i=0; i<2; i++){ | |
4433 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
4434 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
4435 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
4436 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 4437 } |
4438 } | |
4439 } | |
4440 } | |
2967 | 4441 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4442 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
|
4443 if(IS_SKIP(mb_type)) |
666 | 4444 mx=my=0; |
4445 else{ | |
4446 mx = h263_decode_motion(s, 0, 1); | |
4447 my = h263_decode_motion(s, 0, 1); | |
4448 } | |
2967 | 4449 |
262 | 4450 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
|
4451 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 4452 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_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
|
4453 s->current_picture.mb_type[xy]= mb_type; |
262 | 4454 } else { /* I-Frame */ |
1482 | 4455 do{ |
4456 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
4457 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4458 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4459 return -1; |
4460 } | |
4461 }while(cbpc == 8); | |
4462 | |
262 | 4463 dquant = cbpc & 4; |
4464 s->mb_intra = 1; | |
4465 intra: | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4466 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4467 if(s->ac_pred) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4468 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
|
4469 else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4470 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
2967 | 4471 |
544 | 4472 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1482 | 4473 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4474 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4475 return -1; |
4476 } | |
0 | 4477 cbp = (cbpc & 3) | (cbpy << 2); |
3282 | 4478 |
4479 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; | |
4480 | |
0 | 4481 if (dquant) { |
1652 | 4482 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
0 | 4483 } |
2967 | 4484 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4485 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4486 s->interlaced_dct= get_bits1(&s->gb); |
575 | 4487 |
2632 | 4488 s->dsp.clear_blocks(s->block[0]); |
575 | 4489 /* decode each block */ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4490 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4491 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
|
4492 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4493 cbp+=cbp; |
575 | 4494 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4495 goto end; |
0 | 4496 } |
4497 | |
4498 /* decode each block */ | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4499 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4500 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
|
4501 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4502 cbp+=cbp; |
0 | 4503 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4504 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4505 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4506 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4507 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4508 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
|
4509 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
6481 | 4510 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
|
4511 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4512 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4513 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4514 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4515 |
2967 | 4516 return SLICE_OK; |
0 | 4517 } |
4518 | |
262 | 4519 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 4520 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
4521 int code, val, sign, shift, l; |
544 | 4522 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 4523 |
4524 if (code == 0) | |
4525 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
|
4526 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
|
4527 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4528 |
21 | 4529 sign = get_bits1(&s->gb); |
262 | 4530 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
|
4531 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4532 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4533 val = (val - 1) << shift; |
0 | 4534 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
|
4535 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4536 } |
0 | 4537 if (sign) |
4538 val = -val; | |
4539 val += pred; | |
475 | 4540 |
0 | 4541 /* modulo decoding */ |
4542 if (!s->h263_long_vectors) { | |
2093 | 4543 l = INT_BIT - 5 - f_code; |
4544 val = (val<<l)>>l; | |
0 | 4545 } else { |
4546 /* horrible h263 long vector mode */ | |
4547 if (pred < -31 && val < -63) | |
4548 val += 64; | |
4549 if (pred > 32 && val > 63) | |
4550 val -= 64; | |
2967 | 4551 |
0 | 4552 } |
4553 return val; | |
4554 } | |
4555 | |
78 | 4556 /* Decodes RVLC of H.263+ UMV */ |
4557 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
4558 { | |
4559 int code = 0, sign; | |
2967 | 4560 |
78 | 4561 if (get_bits1(&s->gb)) /* Motion difference = 0 */ |
4562 return pred; | |
2967 | 4563 |
78 | 4564 code = 2 + get_bits1(&s->gb); |
2967 | 4565 |
78 | 4566 while (get_bits1(&s->gb)) |
4567 { | |
4568 code <<= 1; | |
4569 code += get_bits1(&s->gb); | |
4570 } | |
4571 sign = code & 1; | |
4572 code >>= 1; | |
2967 | 4573 |
78 | 4574 code = (sign) ? (pred - code) : (pred + code); |
9999
c78fd9154378
Change av_log() calls surrounded by '#ifdef DEBUG' into dprintf macros.
diego
parents:
9591
diff
changeset
|
4575 dprintf(s->avctx,"H.263+ UMV Motion = %d\n", code); |
2967 | 4576 return code; |
78 | 4577 |
4578 } | |
4579 | |
0 | 4580 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
4581 int n, int coded) | |
4582 { | |
4583 int code, level, i, j, last, run; | |
4584 RLTable *rl = &rl_inter; | |
1064 | 4585 const uint8_t *scan_table; |
1637 | 4586 GetBitContext gb= s->gb; |
0 | 4587 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4588 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4589 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4590 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4591 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4592 if (s->ac_pred) { |
2967 | 4593 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4594 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4595 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4596 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4597 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4598 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4599 /* DC coef */ |
1641 | 4600 if(s->codec_id == CODEC_ID_RV10){ |
8590 | 4601 #if CONFIG_RV10_DECODER |
6481 | 4602 if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) { |
0 | 4603 int component, diff; |
4604 component = (n <= 3 ? 0 : n - 4 + 1); | |
4605 level = s->last_dc[component]; | |
4606 if (s->rv10_first_dc_coded[component]) { | |
4607 diff = rv_decode_dc(s, n); | |
4608 if (diff == 0xffff) | |
4609 return -1; | |
4610 level += diff; | |
4611 level = level & 0xff; /* handle wrap round */ | |
4612 s->last_dc[component] = level; | |
4613 } else { | |
4614 s->rv10_first_dc_coded[component] = 1; | |
4615 } | |
1090 | 4616 } else { |
4617 level = get_bits(&s->gb, 8); | |
1975 | 4618 if (level == 255) |
4619 level = 128; | |
1090 | 4620 } |
2639 | 4621 #endif |
1090 | 4622 }else{ |
0 | 4623 level = get_bits(&s->gb, 8); |
1089 | 4624 if((level&0x7F) == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4625 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
7831 | 4626 if(s->error_recognition >= FF_ER_COMPLIANT) |
1752 | 4627 return -1; |
1089 | 4628 } |
0 | 4629 if (level == 255) |
4630 level = 128; | |
4631 } | |
4632 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4633 i = 1; |
0 | 4634 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4635 i = 0; |
0 | 4636 } |
4637 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4638 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4639 goto not_coded; |
0 | 4640 s->block_last_index[n] = i - 1; |
4641 return 0; | |
4642 } | |
1637 | 4643 retry: |
0 | 4644 for(;;) { |
544 | 4645 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
|
4646 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4647 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 4648 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4649 } |
0 | 4650 if (code == rl->n) { |
4651 /* escape */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4652 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4653 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
|
4654 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4655 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
|
4656 if(is11){ |
1356 | 4657 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
|
4658 } else { |
1356 | 4659 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
|
4660 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4661 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4662 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4663 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
|
4664 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
|
4665 if(level == -128){ |
1641 | 4666 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
|
4667 /* XXX: should patch encoder too */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4668 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
|
4669 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4670 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
|
4671 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
|
4672 } |
1089 | 4673 } |
0 | 4674 } |
4675 } else { | |
4676 run = rl->table_run[code]; | |
4677 level = rl->table_level[code]; | |
4678 last = code >= rl->last; | |
21 | 4679 if (get_bits1(&s->gb)) |
0 | 4680 level = -level; |
4681 } | |
4682 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4683 if (i >= 64){ |
1637 | 4684 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ |
5129 | 4685 //Looks like a hack but no, it's the way it is supposed to work ... |
1637 | 4686 rl = &rl_intra_aic; |
4687 i = 0; | |
4688 s->gb= gb; | |
8288 | 4689 s->dsp.clear_block(block); |
1637 | 4690 goto retry; |
4691 } | |
2406 | 4692 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 | 4693 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4694 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4695 j = scan_table[i]; |
0 | 4696 block[j] = level; |
4697 if (last) | |
4698 break; | |
4699 i++; | |
4700 } | |
2967 | 4701 not_coded: |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4702 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4703 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
4704 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4705 } |
0 | 4706 s->block_last_index[n] = i; |
4707 return 0; | |
4708 } | |
4709 | |
1034 | 4710 /** |
4711 * decodes the dc value. | |
4712 * @param n block index (0-3 are luma, 4-5 are chroma) | |
4713 * @param dir_ptr the prediction direction will be stored here | |
4714 * @return the quantized dc | |
4715 */ | |
453 | 4716 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 4717 { |
2003 | 4718 int level, code; |
0 | 4719 |
2967 | 4720 if (n < 4) |
544 | 4721 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
2967 | 4722 else |
544 | 4723 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 4724 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
|
4725 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
0 | 4726 return -1; |
453 | 4727 } |
0 | 4728 if (code == 0) { |
4729 level = 0; | |
4730 } 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
|
4731 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
|
4732 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
|
4733 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
|
4734 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
|
4735 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
|
4736 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
|
4737 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
|
4738 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
|
4739 } |
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
|
4740 }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
|
4741 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
|
4742 } |
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
|
4743 |
453 | 4744 if (code > 8){ |
4745 if(get_bits1(&s->gb)==0){ /* marker */ | |
7831 | 4746 if(s->error_recognition>=2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4747 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
|
4748 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4749 } |
453 | 4750 } |
4751 } | |
0 | 4752 } |
2003 | 4753 |
4754 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); | |
0 | 4755 } |
4756 | |
453 | 4757 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4758 * decodes a block. |
6524 | 4759 * @return <0 if an error occurred |
453 | 4760 */ |
4761 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 4762 int n, int coded, int intra, int rvlc) |
0 | 4763 { |
549 | 4764 int level, i, last, run; |
6211
ed359f380aa7
Revert r11689 and r11690 (uninitalized warning fix) as its theoretically
michael
parents:
6209
diff
changeset
|
4765 int dc_pred_dir; |
575 | 4766 RLTable * rl; |
4767 RL_VLC_ELEM * rl_vlc; | |
1064 | 4768 const uint8_t * scan_table; |
549 | 4769 int qmul, qadd; |
0 | 4770 |
1132 | 4771 //Note intra & rvlc should be optimized away if this is inlined |
2967 | 4772 |
575 | 4773 if(intra) { |
3282 | 4774 if(s->use_intra_dc_vlc){ |
2979 | 4775 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4776 if(s->partitioned_frame){ |
453 | 4777 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
|
4778 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
|
4779 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
|
4780 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 4781 }else{ |
4782 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
4783 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4784 return -1; |
453 | 4785 } |
0 | 4786 block[0] = level; |
549 | 4787 i = 0; |
1520 | 4788 }else{ |
4789 i = -1; | |
3182 | 4790 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0); |
2967 | 4791 } |
6201 | 4792 if (!coded) |
4793 goto not_coded; | |
4794 | |
4795 if(rvlc){ | |
4796 rl = &rvlc_rl_intra; | |
4797 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
4798 }else{ | |
4799 rl = &rl_intra; | |
4800 rl_vlc = rl_intra.rl_vlc[0]; | |
4801 } | |
4802 if (s->ac_pred) { | |
4803 if (dc_pred_dir == 0) | |
4804 scan_table = s->intra_v_scantable.permutated; /* left */ | |
4805 else | |
4806 scan_table = s->intra_h_scantable.permutated; /* top */ | |
4807 } else { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4808 scan_table = s->intra_scantable.permutated; |
6201 | 4809 } |
4810 qmul=1; | |
4811 qadd=0; | |
0 | 4812 } else { |
549 | 4813 i = -1; |
0 | 4814 if (!coded) { |
549 | 4815 s->block_last_index[n] = i; |
0 | 4816 return 0; |
4817 } | |
1132 | 4818 if(rvlc) rl = &rvlc_rl_inter; |
4819 else rl = &rl_inter; | |
2967 | 4820 |
718 | 4821 scan_table = s->intra_scantable.permutated; |
661 | 4822 |
591 | 4823 if(s->mpeg_quant){ |
4824 qmul=1; | |
4825 qadd=0; | |
2967 | 4826 if(rvlc){ |
4827 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
1132 | 4828 }else{ |
2967 | 4829 rl_vlc = rl_inter.rl_vlc[0]; |
1132 | 4830 } |
591 | 4831 }else{ |
4832 qmul = s->qscale << 1; | |
4833 qadd = (s->qscale - 1) | 1; | |
2967 | 4834 if(rvlc){ |
4835 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
1132 | 4836 }else{ |
2967 | 4837 rl_vlc = rl_inter.rl_vlc[s->qscale]; |
1132 | 4838 } |
591 | 4839 } |
0 | 4840 } |
549 | 4841 { |
4842 OPEN_READER(re, &s->gb); | |
0 | 4843 for(;;) { |
549 | 4844 UPDATE_CACHE(re, &s->gb); |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4845 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
549 | 4846 if (level==0) { |
2967 | 4847 /* escape */ |
1132 | 4848 if(rvlc){ |
4849 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
|
4850 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); |
1132 | 4851 return -1; |
4852 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4853 |
1132 | 4854 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
4855 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4856 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
4857 UPDATE_CACHE(re, &s->gb); | |
2967 | 4858 |
1132 | 4859 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
|
4860 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); |
1132 | 4861 return -1; |
4862 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4863 |
1132 | 4864 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); |
2967 | 4865 |
1132 | 4866 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
|
4867 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); |
1132 | 4868 return -1; |
4869 }; SKIP_CACHE(re, &s->gb, 5); | |
4870 | |
4871 level= level * qmul + qadd; | |
4872 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
4873 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
4874 | |
4875 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
|
4876 if(last) i+=192; |
1132 | 4877 }else{ |
549 | 4878 int cache; |
4879 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
|
4880 |
2967 | 4881 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
|
4882 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
|
4883 |
549 | 4884 if (cache&0x80000000) { |
4885 if (cache&0x40000000) { | |
0 | 4886 /* third escape */ |
549 | 4887 SKIP_CACHE(re, &s->gb, 2); |
4888 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4889 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4890 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
4891 UPDATE_CACHE(re, &s->gb); | |
4892 | |
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
|
4893 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
|
4894 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
|
4895 }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
|
4896 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
|
4897 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
|
4898 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
|
4899 }; 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
|
4900 |
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
|
4901 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
|
4902 |
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
|
4903 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
|
4904 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
|
4905 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
|
4906 }; 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
|
4907 |
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
|
4908 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
|
4909 } |
2967 | 4910 |
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
|
4911 #if 0 |
7831 | 4912 if(s->error_recognition >= FF_ER_COMPLIANT){ |
4001 | 4913 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
|
4914 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
498 | 4915 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 4916 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
|
4917 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
|
4918 return -1; |
453 | 4919 } |
7831 | 4920 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
|
4921 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
|
4922 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
|
4923 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
|
4924 } |
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
|
4925 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
|
4926 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
|
4927 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
|
4928 } |
453 | 4929 } |
4930 } | |
4931 } | |
4932 #endif | |
2979 | 4933 if (level>0) level= level * qmul + qadd; |
549 | 4934 else level= level * qmul - qadd; |
4935 | |
2080 | 4936 if((unsigned)(level + 2048) > 4095){ |
7831 | 4937 if(s->error_recognition > FF_ER_COMPLIANT){ |
2080 | 4938 if(level > 2560 || level<-2560){ |
4939 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | |
4940 return -1; | |
4941 } | |
4942 } | |
4943 level= level<0 ? -2048 : 2047; | |
4944 } | |
4945 | |
549 | 4946 i+= run + 1; |
4947 if(last) i+=192; | |
0 | 4948 } else { |
4949 /* second escape */ | |
549 | 4950 #if MIN_CACHE_BITS < 20 |
4951 LAST_SKIP_BITS(re, &s->gb, 2); | |
4952 UPDATE_CACHE(re, &s->gb); | |
4953 #else | |
4954 SKIP_BITS(re, &s->gb, 2); | |
4955 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4956 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4957 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing |
4958 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4959 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4960 } |
4961 } else { | |
4962 /* first escape */ | |
549 | 4963 #if MIN_CACHE_BITS < 19 |
4964 LAST_SKIP_BITS(re, &s->gb, 1); | |
4965 UPDATE_CACHE(re, &s->gb); | |
4966 #else | |
4967 SKIP_BITS(re, &s->gb, 1); | |
4968 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4969 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4970 i+= run; |
4971 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4972 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4973 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4974 } |
1132 | 4975 } |
0 | 4976 } else { |
549 | 4977 i+= run; |
4978 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4979 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4980 } |
549 | 4981 if (i > 62){ |
4982 i-= 192; | |
4983 if(i&(~63)){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4984 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
|
4985 return -1; |
549 | 4986 } |
4987 | |
4988 block[scan_table[i]] = level; | |
0 | 4989 break; |
549 | 4990 } |
4991 | |
4992 block[scan_table[i]] = level; | |
0 | 4993 } |
549 | 4994 CLOSE_READER(re, &s->gb); |
4995 } | |
0 | 4996 not_coded: |
1520 | 4997 if (intra) { |
3282 | 4998 if(!s->use_intra_dc_vlc){ |
2003 | 4999 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); |
2967 | 5000 |
3181 | 5001 i -= i>>31; //if(i == -1) i=0; |
1520 | 5002 } |
5003 | |
0 | 5004 mpeg4_pred_ac(s, block, n, dc_pred_dir); |
5005 if (s->ac_pred) { | |
549 | 5006 i = 63; /* XXX: not optimal */ |
0 | 5007 } |
5008 } | |
549 | 5009 s->block_last_index[n] = i; |
0 | 5010 return 0; |
5011 } | |
5012 | |
5013 /* most is hardcoded. should extend to handle all h263 streams */ | |
5014 int h263_decode_picture_header(MpegEncContext *s) | |
5015 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5016 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5017 uint32_t startcode; |
2967 | 5018 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5019 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5020 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5021 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5022 |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
9999
diff
changeset
|
5023 for(i= get_bits_left(&s->gb); i>24; i-=8) { |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5024 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
2967 | 5025 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5026 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5027 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5028 } |
2967 | 5029 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5030 if (startcode != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5031 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 5032 return -1; |
355 | 5033 } |
5034 /* temporal reference */ | |
1865 | 5035 i = get_bits(&s->gb, 8); /* picture timestamp */ |
5036 if( (s->picture_number&~0xFF)+i < s->picture_number) | |
5037 i+= 256; | |
2886 | 5038 s->current_picture_ptr->pts= |
1865 | 5039 s->picture_number= (s->picture_number&~0xFF) + i; |
355 | 5040 |
2967 | 5041 /* PTYPE starts here */ |
355 | 5042 if (get_bits1(&s->gb) != 1) { |
5043 /* marker */ | |
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, "Bad marker\n"); |
355 | 5045 return -1; |
5046 } | |
5047 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5048 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 5049 return -1; /* h263 id */ |
5050 } | |
5051 skip_bits1(&s->gb); /* split screen off */ | |
5052 skip_bits1(&s->gb); /* camera off */ | |
5053 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 5054 |
5055 format = get_bits(&s->gb, 3); | |
355 | 5056 /* |
5057 0 forbidden | |
5058 1 sub-QCIF | |
5059 10 QCIF | |
2979 | 5060 7 extended PTYPE (PLUSPTYPE) |
355 | 5061 */ |
0 | 5062 |
161 | 5063 if (format != 7 && format != 6) { |
0 | 5064 s->h263_plus = 0; |
5065 /* H.263v1 */ | |
5066 width = h263_format[format][0]; | |
5067 height = h263_format[format][1]; | |
5068 if (!width) | |
5069 return -1; | |
2967 | 5070 |
6481 | 5071 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); |
0 | 5072 |
2967 | 5073 s->h263_long_vectors = get_bits1(&s->gb); |
0 | 5074 |
355 | 5075 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5076 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); |
2979 | 5077 return -1; /* SAC: off */ |
355 | 5078 } |
1633 | 5079 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5080 s->unrestricted_mv = s->h263_long_vectors || s->obmc; | |
2967 | 5081 |
9104 | 5082 s->pb_frame = get_bits1(&s->gb); |
1644 | 5083 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 5084 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
1393 | 5085 |
5086 s->width = width; | |
5087 s->height = height; | |
1865 | 5088 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
2637 | 5089 s->avctx->time_base= (AVRational){1001, 30000}; |
0 | 5090 } else { |
161 | 5091 int ufep; |
2967 | 5092 |
0 | 5093 /* H.263v2 */ |
161 | 5094 s->h263_plus = 1; |
5095 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 5096 |
2967 | 5097 /* ufep other than 0 and 1 are reserved */ |
161 | 5098 if (ufep == 1) { |
2967 | 5099 /* OPPTYPE */ |
161 | 5100 format = get_bits(&s->gb, 3); |
4652 | 5101 dprintf(s->avctx, "ufep=1, format: %d\n", format); |
1872 | 5102 s->custom_pcf= get_bits1(&s->gb); |
5513 | 5103 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ |
1644 | 5104 if (get_bits1(&s->gb) != 0) { |
5105 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); | |
5106 } | |
1633 | 5107 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5108 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ | |
1644 | 5109 s->loop_filter= get_bits1(&s->gb); |
5110 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; | |
2967 | 5111 |
1661 | 5112 s->h263_slice_structured= get_bits1(&s->gb); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5113 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5114 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
|
5115 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5116 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5117 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
|
5118 } |
1637 | 5119 s->alt_inter_vlc= get_bits1(&s->gb); |
1639 | 5120 s->modified_quant= get_bits1(&s->gb); |
1644 | 5121 if(s->modified_quant) |
5122 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 5123 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5124 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 5125 |
161 | 5126 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 5127 } else if (ufep != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5128 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); |
0 | 5129 return -1; |
355 | 5130 } |
2967 | 5131 |
78 | 5132 /* MPPTYPE */ |
1655 | 5133 s->pict_type = get_bits(&s->gb, 3); |
5134 switch(s->pict_type){ | |
6481 | 5135 case 0: s->pict_type= FF_I_TYPE;break; |
5136 case 1: s->pict_type= FF_P_TYPE;break; | |
9104 | 5137 case 2: s->pict_type= FF_P_TYPE;s->pb_frame = 3;break; |
6481 | 5138 case 3: s->pict_type= FF_B_TYPE;break; |
5139 case 7: s->pict_type= FF_I_TYPE;break; //ZYGO | |
1655 | 5140 default: |
0 | 5141 return -1; |
1655 | 5142 } |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5143 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5144 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
|
5145 skip_bits(&s->gb, 4); |
2967 | 5146 |
78 | 5147 /* Get the picture dimensions */ |
161 | 5148 if (ufep) { |
5149 if (format == 6) { | |
5150 /* Custom Picture Format (CPFMT) */ | |
355 | 5151 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4652 | 5152 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info); |
355 | 5153 /* aspect ratios: |
5154 0 - forbidden | |
5155 1 - 1:1 | |
5156 2 - 12:11 (CIF 4:3) | |
5157 3 - 10:11 (525-type 4:3) | |
5158 4 - 16:11 (CIF 16:9) | |
5159 5 - 40:33 (525-type 16:9) | |
5160 6-14 - reserved | |
5161 */ | |
161 | 5162 width = (get_bits(&s->gb, 9) + 1) * 4; |
5163 skip_bits1(&s->gb); | |
5164 height = get_bits(&s->gb, 9) * 4; | |
4652 | 5165 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
|
5166 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 5167 /* aspected dimensions */ |
1548 | 5168 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); |
5169 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); | |
887 | 5170 }else{ |
1548 | 5171 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
355 | 5172 } |
5173 } else { | |
161 | 5174 width = h263_format[format][0]; |
5175 height = h263_format[format][1]; | |
1865 | 5176 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
161 | 5177 } |
5178 if ((width == 0) || (height == 0)) | |
5179 return -1; | |
5180 s->width = width; | |
5181 s->height = height; | |
1872 | 5182 |
5183 if(s->custom_pcf){ | |
5184 int gcd; | |
2637 | 5185 s->avctx->time_base.den= 1800000; |
5186 s->avctx->time_base.num= 1000 + get_bits1(&s->gb); | |
5187 s->avctx->time_base.num*= get_bits(&s->gb, 7); | |
5188 if(s->avctx->time_base.num == 0){ | |
1872 | 5189 av_log(s, AV_LOG_ERROR, "zero framerate\n"); |
5190 return -1; | |
5191 } | |
8611 | 5192 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); |
2637 | 5193 s->avctx->time_base.den /= gcd; |
5194 s->avctx->time_base.num /= gcd; | |
5195 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num); | |
1872 | 5196 }else{ |
2637 | 5197 s->avctx->time_base= (AVRational){1001, 30000}; |
1872 | 5198 } |
5199 } | |
2967 | 5200 |
1872 | 5201 if(s->custom_pcf){ |
5202 skip_bits(&s->gb, 2); //extended Temporal reference | |
5203 } | |
5204 | |
5205 if (ufep) { | |
1089 | 5206 if (s->umvplus) { |
5207 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
2967 | 5208 skip_bits1(&s->gb); |
161 | 5209 } |
1661 | 5210 if(s->h263_slice_structured){ |
5211 if (get_bits1(&s->gb) != 0) { | |
5212 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); | |
5213 } | |
5214 if (get_bits1(&s->gb) != 0) { | |
5215 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); | |
5216 } | |
5217 } | |
78 | 5218 } |
2967 | 5219 |
0 | 5220 s->qscale = get_bits(&s->gb, 5); |
5221 } | |
1670 | 5222 |
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
|
5223 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
|
5224 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
|
5225 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
|
5226 |
9104 | 5227 if (s->pb_frame) { |
5228 skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ | |
5229 if (s->custom_pcf) | |
5230 skip_bits(&s->gb, 2); //extended Temporal reference | |
5231 skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ | |
5232 } | |
5233 | |
0 | 5234 /* PEI */ |
21 | 5235 while (get_bits1(&s->gb) != 0) { |
5236 skip_bits(&s->gb, 8); | |
0 | 5237 } |
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
|
5238 |
1670 | 5239 if(s->h263_slice_structured){ |
5240 if (get_bits1(&s->gb) != 1) { | |
5241 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); | |
5242 return -1; | |
5243 } | |
5244 | |
5245 ff_h263_decode_mba(s); | |
5246 | |
5247 if (get_bits1(&s->gb) != 1) { | |
5248 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
5249 return -1; | |
5250 } | |
5251 } | |
0 | 5252 s->f_code = 1; |
2967 | 5253 |
498 | 5254 if(s->h263_aic){ |
2967 | 5255 s->y_dc_scale_table= |
1639 | 5256 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 5257 }else{ |
5258 s->y_dc_scale_table= | |
5259 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
5260 } | |
5261 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5262 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
5403 | 5263 show_pict_info(s); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5264 } |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5265 #if 1 |
8612 | 5266 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
|
5267 int i,j; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5268 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
|
5269 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5270 for(i=0; i<13; i++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5271 for(j=0; j<3; j++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5272 int v= get_bits(&s->gb, 8); |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5273 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
|
5274 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
|
5275 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5276 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5277 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5278 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
|
5279 } |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5280 #endif |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5281 |
0 | 5282 return 0; |
5283 } | |
5284 | |
1914 | 5285 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
|
5286 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5287 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5288 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5289 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5290 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5291 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
|
5292 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
|
5293 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5294 int virtual_ref[2][2]; |
753 | 5295 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5296 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5297 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5298 int h= s->height; |
753 | 5299 int min_ab; |
5300 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5301 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
|
5302 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5303 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5304 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5305 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
|
5306 if(length){ |
1914 | 5307 x= get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5308 } |
1914 | 5309 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */ |
2967 | 5310 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5311 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
|
5312 if(length){ |
1914 | 5313 y=get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5314 } |
1914 | 5315 skip_bits1(gb); /* marker bit */ |
255 | 5316 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy); |
9290
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5317 s->sprite_traj[i][0]= d[i][0]= x; |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5318 s->sprite_traj[i][1]= d[i][1]= y; |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5319 } |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5320 for(; i<4; i++) |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5321 s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0; |
254
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 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5324 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
|
5325 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5326 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5327 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5328 // Note, the 4th point isn't used for GMC |
262 | 5329 if(s->divx_version==500 && s->divx_build==413){ |
5330 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
5331 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
5332 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
5333 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
5334 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
5335 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
5336 } else { | |
5337 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
5338 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
5339 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
5340 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
5341 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
5342 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
5343 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5344 /* 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
|
5345 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ |
2967 | 5346 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5347 // 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
|
5348 // 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
|
5349 // 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
|
5350 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form |
2967 | 5351 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 5352 + 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 | 5353 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 5354 + 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 | 5355 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 5356 + 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 | 5357 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 5358 + 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 | 5359 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5360 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5361 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5362 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5363 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5364 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5365 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5366 s->sprite_offset[1][1]= 0; |
753 | 5367 s->sprite_delta[0][0]= a; |
5368 s->sprite_delta[0][1]= 0; | |
5369 s->sprite_delta[1][0]= 0; | |
5370 s->sprite_delta[1][1]= a; | |
5371 s->sprite_shift[0]= 0; | |
5372 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5373 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5374 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5375 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
|
5376 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
|
5377 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
|
5378 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 5379 s->sprite_delta[0][0]= a; |
5380 s->sprite_delta[0][1]= 0; | |
5381 s->sprite_delta[1][0]= 0; | |
5382 s->sprite_delta[1][1]= a; | |
5383 s->sprite_shift[0]= 0; | |
5384 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5385 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5386 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5387 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 5388 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
5389 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
5390 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5391 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 5392 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
5393 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
5394 + (1<<(alpha+rho-1)); | |
5395 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
5396 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
2967 | 5397 +2*w2*r*sprite_ref[0][0] |
5398 - 16*w2 | |
753 | 5399 + (1<<(alpha+rho+1))); |
2967 | 5400 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) |
753 | 5401 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) |
2967 | 5402 +2*w2*r*sprite_ref[0][1] |
753 | 5403 - 16*w2 |
5404 + (1<<(alpha+rho+1))); | |
5405 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
5406 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
5407 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
5408 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
2967 | 5409 |
753 | 5410 s->sprite_shift[0]= alpha+rho; |
5411 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
|
5412 break; |
753 | 5413 case 3: |
847 | 5414 min_ab= FFMIN(alpha, beta); |
753 | 5415 w3= w2>>min_ab; |
5416 h3= h2>>min_ab; | |
5417 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
5418 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
5419 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
5420 + (1<<(alpha+beta+rho-min_ab-1)); | |
5421 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
5422 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
5423 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
5424 + (1<<(alpha+beta+rho-min_ab-1)); | |
5425 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
5426 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
5427 + 2*w2*h3*r*sprite_ref[0][0] | |
5428 - 16*w2*h3 | |
5429 + (1<<(alpha+beta+rho-min_ab+1)); | |
5430 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
5431 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
5432 + 2*w2*h3*r*sprite_ref[0][1] | |
5433 - 16*w2*h3 | |
5434 + (1<<(alpha+beta+rho-min_ab+1)); | |
5435 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
5436 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
5437 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
5438 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
2967 | 5439 |
753 | 5440 s->sprite_shift[0]= alpha + beta + rho - min_ab; |
5441 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
|
5442 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5443 } |
2967 | 5444 /* try to simplify the situation */ |
753 | 5445 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
5446 && s->sprite_delta[0][1] == 0 | |
5447 && s->sprite_delta[1][0] == 0 | |
5448 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 5449 { |
753 | 5450 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
5451 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
5452 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
5453 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
5454 s->sprite_delta[0][0]= a; | |
5455 s->sprite_delta[0][1]= 0; | |
5456 s->sprite_delta[1][0]= 0; | |
5457 s->sprite_delta[1][1]= a; | |
5458 s->sprite_shift[0]= 0; | |
5459 s->sprite_shift[1]= 0; | |
255 | 5460 s->real_sprite_warping_points=1; |
5461 } | |
753 | 5462 else{ |
5463 int shift_y= 16 - s->sprite_shift[0]; | |
5464 int shift_c= 16 - s->sprite_shift[1]; | |
5465 //printf("shifts %d %d\n", shift_y, shift_c); | |
5466 for(i=0; i<2; i++){ | |
5467 s->sprite_offset[0][i]<<= shift_y; | |
5468 s->sprite_offset[1][i]<<= shift_c; | |
5469 s->sprite_delta[0][i]<<= shift_y; | |
5470 s->sprite_delta[1][i]<<= shift_y; | |
5471 s->sprite_shift[i]= 16; | |
5472 } | |
255 | 5473 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 5474 } |
5475 #if 0 | |
5476 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", | |
5477 vop_ref[0][0], vop_ref[0][1], | |
5478 vop_ref[1][0], vop_ref[1][1], | |
5479 vop_ref[2][0], vop_ref[2][1], | |
2967 | 5480 sprite_ref[0][0], sprite_ref[0][1], |
5481 sprite_ref[1][0], sprite_ref[1][1], | |
5482 sprite_ref[2][0], sprite_ref[2][1], | |
5483 virtual_ref[0][0], virtual_ref[0][1], | |
753 | 5484 virtual_ref[1][0], virtual_ref[1][1] |
5485 ); | |
2967 | 5486 |
753 | 5487 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", |
5488 s->sprite_offset[0][0], s->sprite_offset[0][1], | |
5489 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
5490 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
5491 s->sprite_shift[0] | |
5492 ); | |
5493 #endif | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5494 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5495 |
942 | 5496 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
5497 int hours, minutes, seconds; | |
5498 | |
5499 hours= get_bits(gb, 5); | |
5500 minutes= get_bits(gb, 6); | |
5501 skip_bits1(gb); | |
5502 seconds= get_bits(gb, 6); | |
5503 | |
5504 s->time_base= seconds + 60*(minutes + 60*hours); | |
5505 | |
5506 skip_bits1(gb); | |
5507 skip_bits1(gb); | |
2967 | 5508 |
942 | 5509 return 0; |
5510 } | |
5511 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5512 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
|
5513 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
|
5514 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5515 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5516 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
|
5517 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
|
5518 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
|
5519 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
|
5520 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
|
5521 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5522 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5523 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5524 //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
|
5525 s->aspect_ratio_info= get_bits(gb, 4); |
2967 | 5526 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
1548 | 5527 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width |
5528 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height | |
887 | 5529 }else{ |
1548 | 5530 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
|
5531 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5532 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5533 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
|
5534 int chroma_format= get_bits(gb, 2); |
8690 | 5535 if(chroma_format!=CHROMA_420){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5536 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
|
5537 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5538 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
|
5539 if(get_bits1(gb)){ /* vbv parameters */ |
2979 | 5540 get_bits(gb, 15); /* first_half_bitrate */ |
5541 skip_bits1(gb); /* marker */ | |
5542 get_bits(gb, 15); /* latter_half_bitrate */ | |
5543 skip_bits1(gb); /* marker */ | |
5544 get_bits(gb, 15); /* first_half_vbv_buffer_size */ | |
5545 skip_bits1(gb); /* marker */ | |
5546 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ | |
5547 get_bits(gb, 11); /* first_half_vbv_occupancy */ | |
5548 skip_bits1(gb); /* marker */ | |
5549 get_bits(gb, 15); /* latter_half_vbv_occupancy */ | |
5550 skip_bits1(gb); /* marker */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5551 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5552 }else{ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5553 // 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
|
5554 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5555 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5556 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5557 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5558 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
|
5559 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
|
5560 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
|
5561 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
|
5562 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
|
5563 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5564 |
1411 | 5565 check_marker(gb, "before time_increment_resolution"); |
2967 | 5566 |
2637 | 5567 s->avctx->time_base.den = get_bits(gb, 16); |
2812 | 5568 if(!s->avctx->time_base.den){ |
5569 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n"); | |
5570 return -1; | |
5571 } | |
2967 | 5572 |
2637 | 5573 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
|
5574 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
|
5575 s->time_increment_bits = 1; |
2967 | 5576 |
1411 | 5577 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
|
5578 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5579 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ |
2637 | 5580 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits); |
5581 }else | |
5582 s->avctx->time_base.num = 1; | |
5583 | |
2034 | 5584 s->t_frame=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5585 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5586 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
|
5587 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5588 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5589 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5590 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5591 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5592 skip_bits1(gb); /* marker */ |
8612 | 5593 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
|
5594 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5595 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5596 // 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
|
5597 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5598 } |
2967 | 5599 |
5600 s->progressive_sequence= | |
1659 | 5601 s->progressive_frame= get_bits1(gb)^1; |
3192 | 5602 s->interlaced_dct=0; |
2967 | 5603 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
1644 | 5604 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
|
5605 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5606 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
|
5607 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5608 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
|
5609 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5610 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
|
5611 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
|
5612 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
|
5613 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
|
5614 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5615 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
|
5616 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5617 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
|
5618 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5619 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
|
5620 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5621 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5622 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
|
5623 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
|
5624 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
|
5625 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
|
5626 return -1; |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5627 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5628 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
|
5629 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
|
5630 if(s->vol_sprite_usage==STATIC_SPRITE) |
2967 | 5631 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
|
5632 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5633 // FIXME sadct disable bit if verid!=1 && shape not rect |
2967 | 5634 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5635 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
|
5636 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
|
5637 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
|
5638 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
|
5639 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5640 s->quant_precision = 5; |
0 | 5641 } |
2967 | 5642 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5643 // 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
|
5644 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5645 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 5646 int i, v; |
2967 | 5647 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5648 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5649 for(i=0; i<64; i++){ |
1092 | 5650 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
|
5651 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
|
5652 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5653 s->chroma_intra_matrix[j]= v; |
2967 | 5654 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5655 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
|
5656 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5657 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
|
5658 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5659 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5660 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5661 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5662 int last=0; |
2979 | 5663 for(i=0; i<64; i++){ |
1057 | 5664 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5665 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5666 if(v==0) break; |
2967 | 5667 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5668 last= v; |
1092 | 5669 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
|
5670 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5671 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
|
5672 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5673 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5674 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5675 for(; i<64; i++){ |
2979 | 5676 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
1411 | 5677 s->intra_matrix[j]= last; |
5678 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
|
5679 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5680 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5681 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5682 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5683 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5684 int last=0; |
2979 | 5685 for(i=0; i<64; i++){ |
1057 | 5686 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5687 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5688 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5689 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5690 last= v; |
1092 | 5691 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
|
5692 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5693 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
|
5694 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5695 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5696 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5697 for(; i<64; i++){ |
2979 | 5698 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
|
5699 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5700 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
|
5701 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5702 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5703 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5704 // 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
|
5705 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5706 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5707 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5708 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
|
5709 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5710 |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5711 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5712 int pos= get_bits_count(gb); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5713 int estimation_method= get_bits(gb, 2); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5714 if(estimation_method<2){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5715 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5716 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
|
5717 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
|
5718 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
|
5719 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
|
5720 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
|
5721 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
|
5722 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5723 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5724 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
|
5725 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
|
5726 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
|
5727 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
|
5728 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5729 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
|
5730 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
|
5731 goto no_cplx_est; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5732 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5733 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5734 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
|
5735 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
|
5736 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
|
5737 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
|
5738 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5739 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5740 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
|
5741 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
|
5742 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
|
5743 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
|
5744 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
|
5745 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
|
5746 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5747 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
|
5748 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
|
5749 goto no_cplx_est; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5750 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5751 if(estimation_method==1){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5752 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
|
5753 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
|
5754 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5755 }else |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5756 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
|
5757 }else{ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5758 no_cplx_est: |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5759 s->cplx_estimation_trash_i= |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5760 s->cplx_estimation_trash_p= |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5761 s->cplx_estimation_trash_b= 0; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5762 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5763 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5764 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
|
5765 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5766 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
|
5767 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5768 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5769 } |
2967 | 5770 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5771 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5772 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
|
5773 if(s->new_pred){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5774 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
|
5775 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
|
5776 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
|
5777 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5778 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
|
5779 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
|
5780 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5781 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5782 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5783 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5784 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5785 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5786 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5787 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5788 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5789 GetBitContext bak= *gb; |
751 | 5790 int ref_layer_id; |
5791 int ref_layer_sampling_dir; | |
5792 int h_sampling_factor_n; | |
5793 int h_sampling_factor_m; | |
5794 int v_sampling_factor_n; | |
5795 int v_sampling_factor_m; | |
2967 | 5796 |
751 | 5797 s->hierachy_type= get_bits1(gb); |
5798 ref_layer_id= get_bits(gb, 4); | |
5799 ref_layer_sampling_dir= get_bits1(gb); | |
5800 h_sampling_factor_n= get_bits(gb, 5); | |
5801 h_sampling_factor_m= get_bits(gb, 5); | |
5802 v_sampling_factor_n= get_bits(gb, 5); | |
5803 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
|
5804 s->enhancement_type= get_bits1(gb); |
2967 | 5805 |
5806 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
|
5807 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ |
2967 | 5808 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5809 // 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
|
5810 s->scalability=0; |
2967 | 5811 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5812 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5813 }else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5814 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); |
2967 | 5815 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5816 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5817 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5818 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5819 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5820 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5821 |
1034 | 5822 /** |
5823 * decodes the user data stuff in the header. | |
6918 | 5824 * Also initializes divx/xvid/lavc_version/build. |
1034 | 5825 */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5826 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
|
5827 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5828 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5829 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
|
5830 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
|
5831 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5832 |
3615 | 5833 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){ |
2804 | 5834 if(show_bits(gb, 23) == 0) break; |
5835 buf[i]= get_bits(gb, 8); | |
5836 } | |
5837 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
|
5838 |
761 | 5839 /* 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
|
5840 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
|
5841 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
|
5842 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
|
5843 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5844 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5845 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
|
5846 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
|
5847 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
|
5848 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
|
5849 s->showed_packed_warning=1; |
2f5101a67500
Only warn about "Invalid and inefficient vfw-avi packed B frames" once.
andoma
parents:
8042
diff
changeset
|
5850 } |
0 | 5851 } |
2967 | 5852 |
761 | 5853 /* ffmpeg detection */ |
2805
55a6659fc2ee
fix user data parsing code so it suppors pre1 and cvs
michael
parents:
2804
diff
changeset
|
5854 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
|
5855 if(e!=4) |
2967 | 5856 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
|
5857 if(e!=4){ |
2814 | 5858 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
|
5859 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
|
5860 build= (ver<<16) + (ver2<<8) + ver3; |
2814 | 5861 } |
5862 if(e!=4){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5863 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5864 s->lavc_build= 4600; |
63 | 5865 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5866 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5867 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5868 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5869 } |
2967 | 5870 |
6908 | 5871 /* Xvid detection */ |
761 | 5872 e=sscanf(buf, "XviD%d", &build); |
5873 if(e==1){ | |
5874 s->xvid_build= build; | |
5875 } | |
5876 | |
255 | 5877 //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
|
5878 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5879 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5880 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5881 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
|
5882 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5883 |
6481 | 5884 s->pict_type = get_bits(gb, 2) + FF_I_TYPE; /* pict type: I = 0 , P = 1 */ |
5885 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
|
5886 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
|
5887 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5888 } |
2967 | 5889 |
6481 | 5890 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
|
5891 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5892 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5893 else |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
5894 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
|
5895 |
262 | 5896 time_incr=0; |
2967 | 5897 while (get_bits1(gb) != 0) |
0 | 5898 time_incr++; |
5899 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5900 check_marker(gb, "before time_increment"); |
2666 | 5901 |
5902 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
|
5903 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n"); |
1068 | 5904 |
5905 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
5906 if(show_bits(gb, s->time_increment_bits+1)&1) break; | |
5907 } | |
1396 | 5908 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5909 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits); |
1068 | 5910 } |
2967 | 5911 |
1411 | 5912 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further |
5913 else time_increment= get_bits(gb, s->time_increment_bits); | |
2967 | 5914 |
1411 | 5915 // printf("%d %X\n", s->time_increment_bits, time_increment); |
2034 | 5916 //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 | 5917 if(s->pict_type!=FF_B_TYPE){ |
324 | 5918 s->last_time_base= s->time_base; |
262 | 5919 s->time_base+= time_incr; |
2637 | 5920 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
|
5921 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5922 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5923 // 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
|
5924 s->time_base++; |
2637 | 5925 s->time+= s->avctx->time_base.den; |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5926 } |
664 | 5927 } |
324 | 5928 s->pp_time= s->time - s->last_non_b_time; |
5929 s->last_non_b_time= s->time; | |
262 | 5930 }else{ |
2637 | 5931 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment; |
664 | 5932 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
5933 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
|
5934 // 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
|
5935 return FRAME_SKIPPED; |
335 | 5936 } |
3247 | 5937 ff_mpeg4_init_direct_mv(s); |
2967 | 5938 |
2034 | 5939 if(s->t_frame==0) s->t_frame= s->pb_time; |
664 | 5940 if(s->t_frame==0) s->t_frame=1; // 1/0 protection |
2967 | 5941 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) |
664 | 5942 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
2967 | 5943 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) |
664 | 5944 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
4346 | 5945 if(!s->progressive_sequence){ |
5946 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) | |
5947 return FRAME_SKIPPED; | |
5948 } | |
262 | 5949 } |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4001
diff
changeset
|
5950 //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 | 5951 |
2813
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5952 if(s->avctx->time_base.num) |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5953 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
|
5954 else |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5955 s->current_picture_ptr->pts= AV_NOPTS_VALUE; |
942 | 5956 if(s->avctx->debug&FF_DEBUG_PTS) |
2962 | 5957 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts); |
2034 | 5958 |
1068 | 5959 check_marker(gb, "before vop_coded"); |
2967 | 5960 |
0 | 5961 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5962 if (get_bits1(gb) != 1){ |
2271 | 5963 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
5964 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
|
5965 return FRAME_SKIPPED; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5966 } |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4001
diff
changeset
|
5967 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base, |
2967 | 5968 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time); |
6481 | 5969 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE |
5970 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { | |
0 | 5971 /* rounding type for motion estimation */ |
2979 | 5972 s->no_rounding = get_bits1(gb); |
63 | 5973 } else { |
2979 | 5974 s->no_rounding = 0; |
0 | 5975 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5976 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5977 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5978 if (s->shape != RECT_SHAPE) { |
6481 | 5979 if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) { |
63 | 5980 int width, height, hor_spat_ref, ver_spat_ref; |
2967 | 5981 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5982 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5983 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5984 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5985 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5986 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
|
5987 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5988 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 5989 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5990 skip_bits1(gb); /* change_CR_disable */ |
2967 | 5991 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5992 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5993 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 5994 } |
5995 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5996 //FIXME complexity estimation stuff |
2967 | 5997 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5998 if (s->shape != BIN_ONLY_SHAPE) { |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5999 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
|
6000 if(s->pict_type != FF_I_TYPE) |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6001 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
|
6002 if(s->pict_type == FF_B_TYPE) |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6003 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
|
6004 |
1520 | 6005 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
|
6006 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6007 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
|
6008 s->alternate_scan= get_bits1(gb); |
661 | 6009 }else |
6010 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6011 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
6012 |
718 | 6013 if(s->alternate_scan){ |
1273 | 6014 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
6015 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
6016 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
6017 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 6018 } else{ |
1273 | 6019 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
6020 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
6021 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
6022 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 6023 } |
2967 | 6024 |
6481 | 6025 if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
1914 | 6026 mpeg4_decode_sprite_trajectory(s, gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6027 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
|
6028 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
|
6029 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
6030 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6031 if (s->shape != BIN_ONLY_SHAPE) { |
1644 | 6032 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
|
6033 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6034 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
|
6035 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
|
6036 } |
2967 | 6037 |
6481 | 6038 if (s->pict_type != FF_I_TYPE) { |
2979 | 6039 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
|
6040 if(s->f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6041 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
|
6042 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
|
6043 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6044 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6045 s->f_code=1; |
2967 | 6046 |
6481 | 6047 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
|
6048 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6049 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6050 s->b_code=1; |
906 | 6051 |
6052 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
|
6053 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 | 6054 s->qscale, s->f_code, s->b_code, |
6481 | 6055 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")), |
2967 | 6056 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, |
930 | 6057 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
|
6058 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 | 6059 } |
6060 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6061 if(!s->scalability){ |
6481 | 6062 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
|
6063 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
|
6064 } |
575 | 6065 }else{ |
6066 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6067 int load_backward_shape= get_bits1(gb); |
575 | 6068 if(load_backward_shape){ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6069 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n"); |
575 | 6070 } |
6071 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6072 skip_bits(gb, 2); //ref_select_code |
63 | 6073 } |
6074 } | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6075 /* 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
|
6076 // 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
|
6077 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
|
6078 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
|
6079 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6080 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6081 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6082 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
|
6083 |
2967 | 6084 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
498 | 6085 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; |
6086 | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1364
diff
changeset
|
6087 if(s->workaround_bugs&FF_BUG_EDGE){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6088 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6089 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6090 } |
63 | 6091 return 0; |
0 | 6092 } |
6093 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6094 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6095 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6096 * @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
|
6097 * 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
|
6098 * 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
|
6099 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6100 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
|
6101 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6102 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6103 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6104 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6105 align_get_bits(gb); |
2406 | 6106 |
8612 | 6107 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){ |
2406 | 6108 skip_bits(gb, 24); |
6109 if(get_bits(gb, 8) == 0xF0) | |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6110 goto end; |
2406 | 6111 } |
6112 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6113 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6114 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
|
6115 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
|
6116 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
|
6117 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
|
6118 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
|
6119 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6120 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6121 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6122 |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6123 /* 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
|
6124 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
|
6125 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
|
6126 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6127 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6128 continue; //no startcode |
2967 | 6129 |
942 | 6130 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
|
6131 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
|
6132 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
|
6133 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
|
6134 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
|
6135 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
|
6136 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
|
6137 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
|
6138 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
|
6139 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
|
6140 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
|
6141 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
|
6142 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
|
6143 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
|
6144 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
|
6145 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
|
6146 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
|
6147 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
|
6148 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
|
6149 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
|
6150 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
|
6151 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
|
6152 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
|
6153 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
|
6154 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
|
6155 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
|
6156 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
|
6157 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
|
6158 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
|
6159 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb)); |
942 | 6160 } |
6161 | |
1512 | 6162 if(startcode >= 0x120 && startcode <= 0x12F){ |
2967 | 6163 if(decode_vol_header(s, gb) < 0) |
1396 | 6164 return -1; |
1512 | 6165 } |
6166 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
|
6167 decode_user_data(s, gb); |
1512 | 6168 } |
6169 else if(startcode == GOP_STARTCODE){ | |
942 | 6170 mpeg4_decode_gop_header(s, gb); |
1512 | 6171 } |
6172 else if(startcode == VOP_STARTCODE){ | |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6173 break; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6174 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6175 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6176 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6177 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6178 } |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6179 end: |
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6180 if(s->flags& CODEC_FLAG_LOW_DELAY) |
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6181 s->low_delay=1; |
8418
f75be04312dc
Fix PTS returned by the demuxers for mpeg4 without a decoder.
michael
parents:
8417
diff
changeset
|
6182 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
|
6183 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
|
6184 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6185 |
0 | 6186 /* don't understand why they choose a different header ! */ |
6187 int intel_h263_decode_picture_header(MpegEncContext *s) | |
6188 { | |
6189 int format; | |
6190 | |
6191 /* picture header */ | |
1257 | 6192 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
|
6193 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 6194 return -1; |
355 | 6195 } |
6196 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 6197 |
355 | 6198 if (get_bits1(&s->gb) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6199 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
2979 | 6200 return -1; /* marker */ |
355 | 6201 } |
6202 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6203 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 6204 return -1; /* h263 id */ |
6205 } | |
6206 skip_bits1(&s->gb); /* split screen off */ | |
6207 skip_bits1(&s->gb); /* camera off */ | |
6208 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 6209 |
6210 format = get_bits(&s->gb, 3); | |
355 | 6211 if (format != 7) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6212 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); |
0 | 6213 return -1; |
355 | 6214 } |
0 | 6215 s->h263_plus = 0; |
6216 | |
6481 | 6217 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); |
2967 | 6218 |
6219 s->unrestricted_mv = get_bits1(&s->gb); | |
0 | 6220 s->h263_long_vectors = s->unrestricted_mv; |
6221 | |
355 | 6222 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6223 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); |
2979 | 6224 return -1; /* SAC: off */ |
355 | 6225 } |
5405
f15e5b4909e1
remove "Advanced Prediction Mode not supported" spam
michael
parents:
5404
diff
changeset
|
6226 s->obmc= get_bits1(&s->gb); |
9008 | 6227 s->pb_frame = get_bits1(&s->gb); |
6228 | |
6229 if(format == 7){ | |
6230 format = get_bits(&s->gb, 3); | |
6231 if(format == 0 || format == 7){ | |
6232 av_log(s->avctx, AV_LOG_ERROR, "Wrong Intel H263 format\n"); | |
6233 return -1; | |
6234 } | |
6235 if(get_bits(&s->gb, 2)) | |
6236 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6237 s->loop_filter = get_bits1(&s->gb); | |
6238 if(get_bits1(&s->gb)) | |
6239 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6240 if(get_bits1(&s->gb)) | |
6241 s->pb_frame = 2; | |
6242 if(get_bits(&s->gb, 5)) | |
6243 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6244 if(get_bits(&s->gb, 5) != 1) | |
6245 av_log(s->avctx, AV_LOG_ERROR, "Invalid marker\n"); | |
6246 } | |
6247 if(format == 6){ | |
6248 int ar = get_bits(&s->gb, 4); | |
6249 skip_bits(&s->gb, 9); // display width | |
6250 skip_bits1(&s->gb); | |
6251 skip_bits(&s->gb, 9); // display height | |
6252 if(ar == 15){ | |
6253 skip_bits(&s->gb, 8); // aspect ratio - width | |
6254 skip_bits(&s->gb, 8); // aspect ratio - height | |
6255 } | |
6256 } | |
0 | 6257 |
1644 | 6258 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 6259 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 6260 |
9008 | 6261 if(s->pb_frame){ |
6262 skip_bits(&s->gb, 3); //temporal reference for B-frame | |
6263 skip_bits(&s->gb, 2); //dbquant | |
6264 } | |
6265 | |
0 | 6266 /* PEI */ |
21 | 6267 while (get_bits1(&s->gb) != 0) { |
6268 skip_bits(&s->gb, 8); | |
0 | 6269 } |
6270 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6271 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6272 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6273 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
|
6274 |
5404 | 6275 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
6276 show_pict_info(s); | |
6277 | |
0 | 6278 return 0; |
6279 } | |
144 | 6280 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6281 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
|
6282 { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6283 int format, width, height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6284 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6285 /* picture header */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6286 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
|
6287 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
|
6288 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6289 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6290 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
|
6291 if (format != 0 && format != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6292 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
|
6293 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6294 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6295 s->h263_flv = format+1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6296 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
|
6297 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
|
6298 switch (format) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6299 case 0: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6300 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
|
6301 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
|
6302 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6303 case 1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6304 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
|
6305 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
|
6306 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6307 case 2: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6308 width = 352; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6309 height = 288; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6310 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6311 case 3: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6312 width = 176; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6313 height = 144; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6314 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6315 case 4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6316 width = 128; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6317 height = 96; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6318 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6319 case 5: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6320 width = 320; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6321 height = 240; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6322 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6323 case 6: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6324 width = 160; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6325 height = 120; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6326 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6327 default: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6328 width = height = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6329 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6330 } |
2422 | 6331 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
|
6332 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6333 s->width = width; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6334 s->height = height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6335 |
6481 | 6336 s->pict_type = FF_I_TYPE + get_bits(&s->gb, 2); |
6337 s->dropable= s->pict_type > FF_P_TYPE; | |
1944 | 6338 if (s->dropable) |
6481 | 6339 s->pict_type = FF_P_TYPE; |
2967 | 6340 |
2979 | 6341 skip_bits1(&s->gb); /* deblocking flag */ |
1644 | 6342 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
|
6343 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6344 s->h263_plus = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6345 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6346 s->unrestricted_mv = 1; |
1364 | 6347 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
|
6348 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6349 /* PEI */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6350 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
|
6351 skip_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6352 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6353 s->f_code = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6354 |
1364 | 6355 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
|
6356 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
|
6357 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); |
1364 | 6358 } |
2967 | 6359 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6360 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6361 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
|
6362 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6363 return 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6364 } |