annotate h263.c @ 2437:8a30df830ad6 libavcodec

x86_64 pointer typecast fix by (Martin Drab <drab kepler.fjfi.cvut cz>)
author michael
date Tue, 18 Jan 2005 01:01:54 +0000
parents 18b8b2dcc037
children f5fe61bd08ac
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1 /*
986e461dc072 Initial revision
glantau
parents:
diff changeset
2 * H263/MPEG4 backend for ffmpeg encoder and decoder
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
3 * Copyright (c) 2000,2001 Fabrice Bellard.
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4 * H263+ support.
0
986e461dc072 Initial revision
glantau
parents:
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
986e461dc072 Initial revision
glantau
parents:
diff changeset
7 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
8 * This library is free software; you can redistribute it and/or
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
9 * modify it under the terms of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
10 * License as published by the Free Software Foundation; either
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
11 * version 2 of the License, or (at your option) any later version.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
12 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
13 * This library is distributed in the hope that it will be useful,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
16 * Lesser General Public License for more details.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
17 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
18 * You should have received a copy of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
19 * License along with this library; if not, write to the Free Software
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
21 *
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
22 * ac prediction encoding, b-frame support, error resilience, optimizations,
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
23 * qpel decoding, gmc decoding, interlaced decoding,
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
24 * by Michael Niedermayer <michaelni@gmx.at>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
25 */
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
26
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
27 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
28 * @file h263.c
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1092
diff changeset
29 * h263/mpeg4 codec.
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
30 */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
31
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
32 //#define DEBUG
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
33 #include <limits.h>
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
34
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
35 #include "common.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
36 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
37 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
38 #include "mpegvideo.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
39 #include "h263data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
40 #include "mpeg4data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
41
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
42 //#undef NDEBUG
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
43 //#include <assert.h>
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
44
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
45 #define INTRA_MCBPC_VLC_BITS 6
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
46 #define INTER_MCBPC_VLC_BITS 7
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
47 #define CBPY_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
48 #define MV_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
49 #define DC_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
50 #define SPRITE_TRAJ_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
51 #define MB_TYPE_B_VLC_BITS 4
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
52 #define TEX_VLC_BITS 9
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
53 #define H263_MBTYPE_B_VLC_BITS 6
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
54 #define CBPC_B_VLC_BITS 3
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
55
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
56 #ifdef CONFIG_ENCODERS
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
57 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
58 int n);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
59 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
60 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
61 int n, int dc, uint8_t *scan_table,
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
62 PutBitContext *dc_pb, PutBitContext *ac_pb);
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
63 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
64
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
65 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
66 static int h263p_decode_umotion(MpegEncContext * s, int pred);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
67 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
68 int n, int coded);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
69 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
70 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
71 int n, int coded, int intra, int rvlc);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
72 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
73 #ifdef CONFIG_ENCODERS
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
74 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
75 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
76 #endif //CONFIG_ENCODERS
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
77 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
78 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
79
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
80 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
81 static uint8_t uni_DCtab_lum_len[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
82 static uint8_t uni_DCtab_chrom_len[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
83 static uint16_t uni_DCtab_lum_bits[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
84 static uint16_t uni_DCtab_chrom_bits[512];
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
85
1162
8c15d82c1893 some static -> dynamic alloc & 16->8 bit
michaelni
parents: 1150
diff changeset
86 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
87 static uint8_t fcode_tab[MAX_MV*2+1];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
88 static uint8_t umv_fcode_tab[MAX_MV*2+1];
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
89
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
90 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
91 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
92 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
93 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
2253
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
94 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
95 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
96 //#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
97 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
98 #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
99
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /* 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
101 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
102 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
103 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
104
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
106 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
107 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
108 */
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
109 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
110
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
111 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
112 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
113 #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
114 #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
115 #endif
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
116
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
117 int h263_get_picture_format(int width, int height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
118 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
119 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
120
986e461dc072 Initial revision
glantau
parents:
diff changeset
121 if (width == 128 && height == 96)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
122 format = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
123 else if (width == 176 && height == 144)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
124 format = 2;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
125 else if (width == 352 && height == 288)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
126 format = 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
127 else if (width == 704 && height == 576)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
128 format = 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
129 else if (width == 1408 && height == 1152)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
130 format = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
131 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
132 format = 7;
986e461dc072 Initial revision
glantau
parents:
diff changeset
133 return format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
134 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
135
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
136 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
137
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
138 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
139 int i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
140
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
141 if(aspect.num==0) aspect= (AVRational){1,1};
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
142
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
143 for(i=1; i<6; i++){
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
144 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
145 s->aspect_ratio_info=i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
146 return;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
147 }
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
148 }
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
149
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
150 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
151 }
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
152
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
153 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
154 {
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
155 int format;
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
156
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
157 align_put_bits(&s->pb);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
158
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
159 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
160 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
161 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
162 s->avctx->frame_rate) & 0xff); /* TemporalReference */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
163 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
164 format = 2;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
165 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
166 format = 3;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
167 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
168 format = 4;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
169 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
170 format = 5;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
171 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
172 format = 6;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
173 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
174 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
175 else
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
176 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
177 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
178 if (format == 0) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
179 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
180 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
181 } else if (format == 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, 16, s->width);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
183 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
184 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
185 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
1390
39d07c0263de patch for flv deblocking by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1389
diff changeset
186 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
187 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
188 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
189
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
190 if(s->h263_aic){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
191 s->y_dc_scale_table=
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
192 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
193 }else{
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
194 s->y_dc_scale_table=
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
195 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
196 }
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
197 }
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
198
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
199 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
200 {
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
201 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
202 int best_clock_code=1;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
203 int best_divisor=60;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
204 int best_error= INT_MAX;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
205
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
206 if(s->h263_plus){
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
207 for(i=0; i<2; i++){
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
208 int div, error;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
209 div= (s->avctx->frame_rate_base*1800000LL + 500LL*s->avctx->frame_rate) / ((1000LL+i)*s->avctx->frame_rate);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
210 div= clip(1, div, 127);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
211 error= ABS(s->avctx->frame_rate_base*1800000LL - (1000LL+i)*s->avctx->frame_rate*div);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
212 if(error < best_error){
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
213 best_error= error;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
214 best_divisor= div;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
215 best_clock_code= i;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
216 }
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
217 }
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
218 }
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
219 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
220 coded_frame_rate= 1800000;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
221 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
222
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
223 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
224
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
225 /* Update the pointer to last GOB */
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
226 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
227 put_bits(&s->pb, 22, 0x20); /* PSC */
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
228 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->frame_rate_base /
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
229 (coded_frame_rate_base * (int64_t)s->avctx->frame_rate);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
230 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
231
986e461dc072 Initial revision
glantau
parents:
diff changeset
232 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
233 put_bits(&s->pb, 1, 0); /* h263 id */
986e461dc072 Initial revision
glantau
parents:
diff changeset
234 put_bits(&s->pb, 1, 0); /* split screen off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
235 put_bits(&s->pb, 1, 0); /* camera off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
236 put_bits(&s->pb, 1, 0); /* freeze picture release off */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
237
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
238 format = h263_get_picture_format(s->width, s->height);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
239 if (!s->h263_plus) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
240 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
241 put_bits(&s->pb, 3, format);
986e461dc072 Initial revision
glantau
parents:
diff changeset
242 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
986e461dc072 Initial revision
glantau
parents:
diff changeset
243 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
986e461dc072 Initial revision
glantau
parents:
diff changeset
244 of H.263v1 UMV implies to check the predicted MV after
986e461dc072 Initial revision
glantau
parents:
diff changeset
245 calculation of the current MB to see if we're on the limits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
246 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
247 put_bits(&s->pb, 1, 0); /* SAC: off */
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
248 put_bits(&s->pb, 1, s->obmc); /* advanced prediction mode */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
249 put_bits(&s->pb, 1, 0); /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
250 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
251 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
252 } else {
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
253 int ufep=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
254 /* H.263v2 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
255 /* H.263 Plus PTYPE */
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
256
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
257 put_bits(&s->pb, 3, 7);
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
258 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
259 if (format == 7)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
260 put_bits(&s->pb,3,6); /* Custom Source Format */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
261 else
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
262 put_bits(&s->pb, 3, format);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
263
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
264 put_bits(&s->pb,1, s->custom_pcf);
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
265 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
266 put_bits(&s->pb,1,0); /* SAC: off */
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
267 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
268 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
269 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
270 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
271 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
272 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
273 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
274 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
275 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
276 put_bits(&s->pb,3,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
277
986e461dc072 Initial revision
glantau
parents:
diff changeset
278 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
986e461dc072 Initial revision
glantau
parents:
diff changeset
279
986e461dc072 Initial revision
glantau
parents:
diff changeset
280 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
281 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
282 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
283 put_bits(&s->pb,2,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
284 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
285
986e461dc072 Initial revision
glantau
parents:
diff changeset
286 /* This should be here if PLUSPTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
287 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
288
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
289 if (format == 7) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
290 /* Custom Picture Format (CPFMT) */
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
291 aspect_to_info(s, s->avctx->sample_aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
292
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
293 put_bits(&s->pb,4,s->aspect_ratio_info);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
294 put_bits(&s->pb,9,(s->width >> 2) - 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
295 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
296 put_bits(&s->pb,9,(s->height >> 2));
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
297 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
298 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
299 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
300 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
301 }
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
302 if(s->custom_pcf){
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
303 if(ufep){
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
304 put_bits(&s->pb, 1, best_clock_code);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
305 put_bits(&s->pb, 7, best_divisor);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
306 }
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
307 put_bits(&s->pb, 2, (temp_ref>>8)&3);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
308 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
309
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
310 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
311 if (s->umvplus)
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
312 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
313 //FIXME check actual requested range
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
314 put_bits(&s->pb,2,1); /* unlimited */
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
315 if(s->h263_slice_structured)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
316 put_bits(&s->pb,2,0); /* no weird submodes */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
317
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
318 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
319 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
320
986e461dc072 Initial revision
glantau
parents:
diff changeset
321 put_bits(&s->pb, 1, 0); /* no PEI */
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
322
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
323 if(s->h263_slice_structured){
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
324 put_bits(&s->pb, 1, 1);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
325
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
326 assert(s->mb_x == 0 && s->mb_y == 0);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
327 ff_h263_encode_mba(s);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
328
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
329 put_bits(&s->pb, 1, 1);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
330 }
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
331
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
332 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
333 s->y_dc_scale_table=
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
334 s->c_dc_scale_table= ff_aic_dc_scale_table;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
335 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
336 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
337 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
338 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
339 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
340
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
341 /**
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
342 * Encodes a group of blocks header.
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
343 */
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
344 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
345 {
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
346 put_bits(&s->pb, 17, 1); /* GBSC */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
347
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
348 if(s->h263_slice_structured){
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
349 put_bits(&s->pb, 1, 1);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
350
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
351 ff_h263_encode_mba(s);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
352
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
353 if(s->mb_num > 1583)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
354 put_bits(&s->pb, 1, 1);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
355 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
356 put_bits(&s->pb, 1, 1);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
357 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
358 }else{
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
359 int gob_number= mb_line / s->gob_index;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
360
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
361 put_bits(&s->pb, 5, gob_number); /* GN */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
362 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
363 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
364 }
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
365 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
366
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
367 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
368 int last=0;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
369 int j;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
370 int rate=0;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
371
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
372 for(j=1; j<=block_last_index; j++){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
373 const int index= scantable[j];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
374 int level= block[index];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
375 if(level){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
376 level+= 64;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
377 if((level&(~127)) == 0){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
378 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
379 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
380 }else
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
381 rate += s->ac_esc_length;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
382 level-= 64;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
383
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
384 last= j;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
385 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
386 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
387
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
388 return rate;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
389 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
390
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
391 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
392 {
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
393 int score= 0;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
394 int i, n;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
395 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
396
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
397 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
398
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
399 for(n=0; n<6; n++){
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
400 int16_t *ac_val, *ac_val1;
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
401
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
402 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
403
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
404 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
405 ac_val1= ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
406 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
407 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
408 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
409 ac_val-= s->block_wrap[n]*16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
410 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
411 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
412 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
413 const int level= block[n][s->dsp.idct_permutation[i ]];
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
414 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
415 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
416 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
417 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
418 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
419 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
420 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
421 const int level= block[n][s->dsp.idct_permutation[i ]];
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
422 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
423 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
424 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
425 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
426 }
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
427 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
428 }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
429 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
430 /* left prediction */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
431 ac_val-= 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
432 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
433 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
434 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
435 const int level= block[n][s->dsp.idct_permutation[i<<3]];
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
436 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
437 ac_val1[i ]= level;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
438 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
439 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
440 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
441 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
442 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
443 const int level= block[n][s->dsp.idct_permutation[i<<3]];
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
444 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
445 ac_val1[i ]= level;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
446 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
447 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
448 }
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
449 st[n]= s->intra_v_scantable.permutated;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
450 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
451
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
452 for(i=63; i>0; i--) //FIXME optimize
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
453 if(block[n][ st[n][i] ]) break;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
454 s->block_last_index[n]= i;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
455
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
456 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
457 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
458
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
459 return score < 0;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
460 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
461
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
462 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
463 {
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
464 int i, n;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
465 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
466
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
467 for(n=0; n<6; n++){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
468 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
469
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
470 st[n]= s->intra_scantable.permutated;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
471 if(dir[n]){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
472 /* top prediction */
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
473 for(i=1; i<8; i++){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
474 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
475 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
476 }else{
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
477 /* left prediction */
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
478 for(i=1; i<8; i++){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
479 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
480 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
481 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
482 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
483 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
484
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
485 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
486 * 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
487 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
488 void ff_clean_h263_qscales(MpegEncContext *s){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
489 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
490 int8_t * const qscale_table= s->current_picture.qscale_table;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
491
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
492 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
493 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
494 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
495 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
496 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
497 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
498 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
499 }
1983
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
500
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
501 if(s->codec_id != CODEC_ID_H263P){
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
502 for(i=1; i<s->mb_num; i++){
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
503 int mb_xy= s->mb_index2xy[i];
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
504
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
505 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
506 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
507 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
508 }
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
509 }
1205bf58c420 H.263 MCBPC fix
michael
parents: 1976
diff changeset
510 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
511 }
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
512
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
513 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
514 * 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
515 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
516 void ff_clean_mpeg4_qscales(MpegEncContext *s){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
517 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
518 int8_t * const qscale_table= s->current_picture.qscale_table;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
519
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
520 ff_clean_h263_qscales(s);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
521
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
522 if(s->pict_type== B_TYPE){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
523 int odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
524 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
525 for the actual adaptive quantization */
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
526
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
527 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
528 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
529 odd += qscale_table[mb_xy]&1;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
530 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
531
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
532 if(2*odd > s->mb_num) odd=1;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
533 else odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
534
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
535 for(i=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
536 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
537 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
538 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
539 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
540 qscale_table[mb_xy]= 31;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
541 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
542
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
543 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
544 int mb_xy= s->mb_index2xy[i];
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
545 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
546 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
547 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
548 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
549 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
550 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
551 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
552
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
553 #endif //CONFIG_ENCODERS
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
554 /**
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
555 *
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
556 * @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
557 */
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead 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 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
559 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
560 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
561 int xy= s->block_index[0];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
562 uint16_t time_pp= s->pp_time;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
563 uint16_t time_pb= s->pb_time;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
564 int i;
1053
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
565
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
566 //FIXME avoid divides
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
567
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
568 if(IS_8X8(colocated_mb_type)){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
569 s->mv_type = MV_TYPE_8X8;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
570 for(i=0; i<4; i++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
571 xy= s->block_index[i];
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
572 s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
573 s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
574 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
575 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
576 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1]
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
577 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
578 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
579 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
580 } else if(IS_INTERLACED(colocated_mb_type)){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
581 s->mv_type = MV_TYPE_FIELD;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
582 for(i=0; i<2; i++){
1948
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
583 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
584 if(s->top_field_first){
1948
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
585 time_pp= s->pp_field_time - field_select + i;
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
586 time_pb= s->pb_field_time - field_select + i;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
587 }else{
1948
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
588 time_pp= s->pp_field_time + field_select - i;
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
589 time_pb= s->pb_field_time + field_select - i;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
590 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
591 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
592 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
593 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
594 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
595 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
596 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
597 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
598 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
599 }else{
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
600 s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
601 s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
602 s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->next_picture.motion_val[0][xy][0]
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
603 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
604 s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->next_picture.motion_val[0][xy][1]
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
605 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
606 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
607 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
608 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
609 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
610 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
611 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
612 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
613
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
614 void ff_h263_update_motion_val(MpegEncContext * s){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
615 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
616 //FIXME a lot of thet 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
617 const int wrap = s->b8_stride;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
618 const int xy = s->block_index[0];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
619
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
620 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
621
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
622 if(s->mv_type != MV_TYPE_8X8){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
623 int motion_x, motion_y;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
624 if (s->mb_intra) {
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
625 motion_x = 0;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
626 motion_y = 0;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
627 } else if (s->mv_type == MV_TYPE_16X16) {
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
628 motion_x = s->mv[0][0][0];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
629 motion_y = s->mv[0][0][1];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
630 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
631 int i;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
632 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
633 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
634 motion_x = (motion_x>>1) | (motion_x&1);
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
635 for(i=0; i<2; i++){
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
636 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
637 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
638 }
1948
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
639 s->current_picture.ref_index[0][xy ]=
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
640 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
641 s->current_picture.ref_index[0][xy + wrap ]=
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
642 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
643 }
1948
d10578f7fd40 exporting field_select/ref_index values
michael
parents: 1944
diff changeset
644
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
645 /* 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
646 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
647 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
648 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
649 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
650 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
651 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
652 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
653 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
654 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
655
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
656 if(s->encoding){ //FIXME encoding MUST be cleaned up
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
657 if (s->mv_type == MV_TYPE_8X8)
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
658 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
659 else if(s->mb_intra)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
660 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
661 else
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
662 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
663 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
664 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
665
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
666 #ifdef CONFIG_ENCODERS
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
667
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
668 static inline int get_p_cbp(MpegEncContext * s,
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
669 DCTELEM block[6][64],
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
670 int motion_x, int motion_y){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
671 int cbp, i;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
672
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
673 if(s->flags & CODEC_FLAG_CBP_RD){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
674 int best_cbpy_score= INT_MAX;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
675 int best_cbpc_score= INT_MAX;
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
676 int cbpc = (-1), cbpy= (-1);
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
677 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
678 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
679
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
680 for(i=0; i<4; i++){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
681 int score= inter_MCBPC_bits[i + offset] * lambda;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
682 if(i&1) score += s->coded_score[5];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
683 if(i&2) score += s->coded_score[4];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
684
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
685 if(score < best_cbpc_score){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
686 best_cbpc_score= score;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
687 cbpc= i;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
688 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
689 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
690
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
691 for(i=0; i<16; i++){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
692 int score= cbpy_tab[i ^ 0xF][1] * lambda;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
693 if(i&1) score += s->coded_score[3];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
694 if(i&2) score += s->coded_score[2];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
695 if(i&4) score += s->coded_score[1];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
696 if(i&8) score += s->coded_score[0];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
697
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
698 if(score < best_cbpy_score){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
699 best_cbpy_score= score;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
700 cbpy= i;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
701 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
702 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
703 cbp= cbpc + 4*cbpy;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
704 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
705 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
706 cbp= 0;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
707 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
708
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
709 for (i = 0; i < 6; i++) {
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
710 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
711 s->block_last_index[i]= -1;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
712 memset(s->block[i], 0, sizeof(DCTELEM)*64);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
713 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
714 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
715 }else{
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
716 cbp= 0;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
717 for (i = 0; i < 6; i++) {
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
718 if (s->block_last_index[i] >= 0)
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
719 cbp |= 1 << (5 - i);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
720 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
721 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
722 return cbp;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
723 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
724
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
725 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
726 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
727 int cbp=0, i;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
728
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
729 if(s->flags & CODEC_FLAG_CBP_RD){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
730 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
731 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
732
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
733 for(i=0; i<6; i++){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
734 if(s->coded_score[i] < 0){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
735 score += s->coded_score[i];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
736 cbp |= 1 << (5 - i);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
737 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
738 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
739
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
740 if(cbp){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
741 int zero_score= -6;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
742 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
743 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
744 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
745
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
746 zero_score*= lambda;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
747 if(zero_score <= score){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
748 cbp=0;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
749 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
750 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
751
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
752 for (i = 0; i < 6; i++) {
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
753 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
754 s->block_last_index[i]= -1;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
755 memset(s->block[i], 0, sizeof(DCTELEM)*64);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
756 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
757 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
758 }else{
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
759 for (i = 0; i < 6; i++) {
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
760 if (s->block_last_index[i] >= 0)
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
761 cbp |= 1 << (5 - i);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
762 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
763 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
764 return cbp;
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
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
767 void mpeg4_encode_mb(MpegEncContext * s,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
768 DCTELEM block[6][64],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
769 int motion_x, int motion_y)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
770 {
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
771 int cbpc, cbpy, pred_x, pred_y;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
772 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
773 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
774 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
775 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
776 const int dquant_code[5]= {1,0,9,2,3};
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
777
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
778 // 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
779 if (!s->mb_intra) {
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
780 int i, cbp;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
781
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
782 if(s->pict_type==B_TYPE){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
783 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
784 int mb_type= mb_type_table[s->mv_dir];
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
785
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
786 if(s->mb_x==0){
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
787 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
788 s->last_mv[i][0][0]=
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
789 s->last_mv[i][0][1]=
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
790 s->last_mv[i][1][0]=
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
791 s->last_mv[i][1][1]= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
792 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
793 }
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
794
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
795 assert(s->dquant>=-2 && s->dquant<=2);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
796 assert((s->dquant&1)==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
797 assert(mb_type>=0);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
798
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
799 /* nothing to do if this MB was skiped in the next P Frame */
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
800 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
801 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
802 s->mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
803 s->mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
804 s->mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
805 s->mv[1][0][1]= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
806 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
807 s->qscale -= s->dquant;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
808 // s->mb_skiped=1;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
809
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
810 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
811 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
812
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
813 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
814
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
815 if ((cbp | motion_x | motion_y | mb_type) ==0) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
816 /* direct MB with MV={0,0} */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
817 assert(s->dquant==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
818
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
819 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
820
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
821 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
822 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
823 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
824 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
825 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
826 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
827 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
828
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
829 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
830 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
831 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
832 if(cbp) put_bits(&s->pb, 6, cbp);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
833
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
834 if(cbp && mb_type){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
835 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
836 put_bits(&s->pb, 2, (s->dquant>>2)+3);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
837 else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
838 put_bits(&s->pb, 1, 0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
839 }else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
840 s->qscale -= s->dquant;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
841
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
842 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
843 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
844 put_bits(&s->pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
845 if(mb_type) // not diect mode
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
846 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
847 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
848
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
849 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
850 s->misc_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
851 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
852
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
853 if(mb_type == 0){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
854 assert(s->mv_dir & MV_DIRECT);
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
855 ff_h263_encode_motion(s, motion_x, 1);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
856 ff_h263_encode_motion(s, motion_y, 1);
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
857 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
858 s->f_count++;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
859 }else{
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
860 assert(mb_type > 0 && mb_type < 4);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
861 if(s->mv_type != MV_TYPE_FIELD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
862 if(s->mv_dir & MV_DIR_FORWARD){
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
863 ff_h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
864 ff_h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
865 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
866 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
867 s->f_count++;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
868 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
869 if(s->mv_dir & MV_DIR_BACKWARD){
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
870 ff_h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
871 ff_h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
872 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
873 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
874 s->b_count++;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
875 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
876 }else{
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
877 if(s->mv_dir & MV_DIR_FORWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
878 put_bits(&s->pb, 1, s->field_select[0][0]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
879 put_bits(&s->pb, 1, s->field_select[0][1]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
880 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
881 if(s->mv_dir & MV_DIR_BACKWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
882 put_bits(&s->pb, 1, s->field_select[1][0]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
883 put_bits(&s->pb, 1, s->field_select[1][1]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
884 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
885 if(s->mv_dir & MV_DIR_FORWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
886 for(i=0; i<2; i++){
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
887 ff_h263_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
888 ff_h263_encode_motion(s, s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
889 s->last_mv[0][i][0]= s->mv[0][i][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
890 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
891 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
892 s->f_count++;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
893 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
894 if(s->mv_dir & MV_DIR_BACKWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
895 for(i=0; i<2; i++){
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
896 ff_h263_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
897 ff_h263_encode_motion(s, s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
898 s->last_mv[1][i][0]= s->mv[1][i][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
899 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
900 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
901 s->b_count++;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
902 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
903 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
904 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
905
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
906 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
907 s->mv_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
908 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
909
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
910 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
911 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
912 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
913 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
914
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
915 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
916 s->p_tex_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
917 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
918
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
919 }else{ /* s->pict_type==B_TYPE */
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
920 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
921
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
922 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
923 /* check if the B frames can skip it too, as we must skip it if we skip here
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
924 why didnt they just compress the skip-mb bits instead of reusing them ?! */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
925 if(s->max_b_frames>0){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
926 int i;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
927 int x,y, offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
928 uint8_t *p_pic;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
929
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
930 x= s->mb_x*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
931 y= s->mb_y*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
932 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
933 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
934
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
935 offset= x + y*s->linesize;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
936 p_pic= s->new_picture.data[0] + offset;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
937
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
938 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
939 for(i=0; i<s->max_b_frames; i++){
339
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
940 uint8_t *b_pic;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
941 int diff;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
942 Picture *pic= s->reordered_input_picture[i+1];
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
943
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
944 if(pic==NULL || pic->pict_type!=B_TYPE) break;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
945
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
946 b_pic= pic->data[0] + offset + 16; //FIXME +16
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
947 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
948 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
949 s->mb_skiped=0;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
950 break;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
951 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
952 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
953 }else
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
954 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
955
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
956 if(s->mb_skiped==1){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
957 /* skip macroblock */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
958 put_bits(&s->pb, 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
959
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
960 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
961 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
962 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
963 }
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
964 s->skip_count++;
1271
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
965
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
966 return;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
967 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
968 }
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
969
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
970 put_bits(&s->pb, 1, 0); /* mb coded */
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
971 cbpc = cbp & 3;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
972 cbpy = cbp >> 2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
973 cbpy ^= 0xf;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
974 if(s->mv_type==MV_TYPE_16X16){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
975 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
976 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
977 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
978 inter_MCBPC_code[cbpc]);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
979
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
980 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
981 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
982 put_bits(pb2, 2, dquant_code[s->dquant+2]);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
983
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
984 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
985 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
986 put_bits(pb2, 1, s->interlaced_dct);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
987 put_bits(pb2, 1, 0);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
988 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
989
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
990 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
991 s->misc_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
992 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
993
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
994 /* motion vectors: 16x16 mode */
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
995 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
996
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
997 ff_h263_encode_motion(s, motion_x - pred_x, s->f_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
998 ff_h263_encode_motion(s, motion_y - pred_y, s->f_code);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
999 }else if(s->mv_type==MV_TYPE_FIELD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1000 if(s->dquant) cbpc+= 8;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1001 put_bits(&s->pb,
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1002 inter_MCBPC_bits[cbpc],
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1003 inter_MCBPC_code[cbpc]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1004
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1005 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1006 if(s->dquant)
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1007 put_bits(pb2, 2, dquant_code[s->dquant+2]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1008
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1009 assert(!s->progressive_sequence);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1010 if(cbp)
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1011 put_bits(pb2, 1, s->interlaced_dct);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1012 put_bits(pb2, 1, 1);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1013
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1014 if(interleaved_stats){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1015 s->misc_bits+= get_bits_diff(s);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1016 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1017
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1018 /* motion vectors: 16x8 interlaced mode */
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1019 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1020 pred_y /=2;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1021
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1022 put_bits(&s->pb, 1, s->field_select[0][0]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1023 put_bits(&s->pb, 1, s->field_select[0][1]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1024
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1025 ff_h263_encode_motion(s, s->mv[0][0][0] - pred_x, s->f_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1026 ff_h263_encode_motion(s, s->mv[0][0][1] - pred_y, s->f_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1027 ff_h263_encode_motion(s, s->mv[0][1][0] - pred_x, s->f_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1028 ff_h263_encode_motion(s, s->mv[0][1][1] - pred_y, s->f_code);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1029 }else{
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
1030 assert(s->mv_type==MV_TYPE_8X8);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1031 put_bits(&s->pb,
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1032 inter_MCBPC_bits[cbpc+16],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1033 inter_MCBPC_code[cbpc+16]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1034 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1035
757
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
1036 if(!s->progressive_sequence){
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
1037 if(cbp)
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
1038 put_bits(pb2, 1, s->interlaced_dct);
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
1039 }
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
1040
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1041 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1042 s->misc_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1043 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1044
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1045 for(i=0; i<4; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1046 /* motion vectors: 8x8 mode*/
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1047 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1048
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1049 ff_h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1050 ff_h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1051 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1052 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1053
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1054 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1055 s->mv_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1056 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1057
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1058 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1059 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1060 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1061 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1062
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1063 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1064 s->p_tex_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1065 }
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
1066 s->f_count++;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
1067 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1068 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1069 int cbp;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1070 int dc_diff[6]; //dc values with the dc prediction subtracted
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1071 int dir[6]; //prediction direction
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1072 int zigzag_last_index[6];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1073 uint8_t *scan_table[6];
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
1074 int i;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1075
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1076 for(i=0; i<6; i++){
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
1077 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
1078 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1079
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1080 if(s->flags & CODEC_FLAG_AC_PRED){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1081 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1082 if(!s->ac_pred)
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1083 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
1084 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1085 for(i=0; i<6; i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1086 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
1087 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1088
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1089 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1090 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1091 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1092 if (s->block_last_index[i] >= 1)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1093 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1094 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1095
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1096 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1097 if (s->pict_type == I_TYPE) {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1098 if(s->dquant) cbpc+=4;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1099 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1100 intra_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1101 intra_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1102 } else {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1103 if(s->dquant) cbpc+=8;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1104 put_bits(&s->pb, 1, 0); /* mb coded */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1105 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1106 inter_MCBPC_bits[cbpc + 4],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1107 inter_MCBPC_code[cbpc + 4]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1108 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1109 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
1110 cbpy = cbp >> 2;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1111 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
1112 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1113 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1114
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1115 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1116 put_bits(dc_pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1117 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1118
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1119 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1120 s->misc_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1121 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
1122
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1123 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1124 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1125 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1126 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1127
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1128 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1129 s->i_tex_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1130 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
1131 s->i_count++;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
1132
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1133 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1134 if(s->ac_pred)
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1135 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
1136 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1137 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1138
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1139 void h263_encode_mb(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1140 DCTELEM block[6][64],
986e461dc072 Initial revision
glantau
parents:
diff changeset
1141 int motion_x, int motion_y)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1142 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1143 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1144 int16_t pred_dc;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1145 int16_t rec_intradc[6];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1146 uint16_t *dc_ptr[6];
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1147 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1148 const int dquant_code[5]= {1,0,9,2,3};
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1149
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1150 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1151 if (!s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1152 /* compute cbp */
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
1153 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
1154
1789
acda5fdfd6e7 h263 4mv encoding fix
michael
parents: 1786
diff changeset
1155 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1156 /* skip macroblock */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1157 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
1158 if(interleaved_stats){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1159 s->misc_bits++;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1160 s->last_bits++;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1161 }
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
1162 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
1163
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1164 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1165 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1166 put_bits(&s->pb, 1, 0); /* mb coded */
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1167
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1168 cbpc = cbp & 3;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
1169 cbpy = cbp >> 2;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
1170 if(s->alt_inter_vlc==0 || cbpc!=3)
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
1171 cbpy ^= 0xF;
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1172 if(s->dquant) cbpc+= 8;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1173 if(s->mv_type==MV_TYPE_16X16){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1174 put_bits(&s->pb,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1175 inter_MCBPC_bits[cbpc],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1176 inter_MCBPC_code[cbpc]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1177
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1178 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1179 if(s->dquant)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1180 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1181
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1182 if(interleaved_stats){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1183 s->misc_bits+= get_bits_diff(s);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1184 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1185
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1186 /* motion vectors: 16x16 mode */
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1187 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1188
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1189 if (!s->umvplus) {
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1190 ff_h263_encode_motion(s, motion_x - pred_x, 1);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1191 ff_h263_encode_motion(s, motion_y - pred_y, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1192 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1193 else {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1194 h263p_encode_umotion(s, motion_x - pred_x);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1195 h263p_encode_umotion(s, motion_y - pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1196 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1197 /* To prevent Start Code emulation */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1198 put_bits(&s->pb,1,1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1199 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1200 }else{
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1201 put_bits(&s->pb,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1202 inter_MCBPC_bits[cbpc+16],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1203 inter_MCBPC_code[cbpc+16]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1204 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1205 if(s->dquant)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1206 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1207
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1208 if(interleaved_stats){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1209 s->misc_bits+= get_bits_diff(s);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1210 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1211
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1212 for(i=0; i<4; i++){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1213 /* motion vectors: 8x8 mode*/
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1214 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1215
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1216 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
1217 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1218 if (!s->umvplus) {
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1219 ff_h263_encode_motion(s, motion_x - pred_x, 1);
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1220 ff_h263_encode_motion(s, motion_y - pred_y, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1221 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1222 else {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1223 h263p_encode_umotion(s, motion_x - pred_x);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1224 h263p_encode_umotion(s, motion_y - pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1225 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1226 /* To prevent Start Code emulation */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1227 put_bits(&s->pb,1,1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1228 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1229 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1230 }
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1231
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1232 if(interleaved_stats){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1233 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
1234 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1235 } else {
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1236 assert(s->mb_intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1237
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1238 cbp = 0;
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1239 if (s->h263_aic) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1240 /* Predict DC */
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1241 for(i=0; i<6; i++) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1242 int16_t level = block[i][0];
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1243 int scale;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1244
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1245 if(i<4) scale= s->y_dc_scale;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1246 else scale= s->c_dc_scale;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1247
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1248 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
1249 level -= pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1250 /* Quant */
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1251 if (level >= 0)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1252 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
1253 else
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1254 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
1255
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1256 /* AIC can change CBP */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1257 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
1258 s->block_last_index[i] = -1;
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1259
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1260 if(!s->modified_quant){
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1261 if (level < -127)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1262 level = -127;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1263 else if (level > 127)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1264 level = 127;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1265 }
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1266
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1267 block[i][0] = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1268 /* Reconstruction */
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1269 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
1270 /* Oddify */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1271 rec_intradc[i] |= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1272 //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
1273 // rec_intradc[i]++;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1274 /* Clipping */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1275 if (rec_intradc[i] < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1276 rec_intradc[i] = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1277 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
1278 rec_intradc[i] = 2047;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1279
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1280 /* Update AC/DC tables */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1281 *dc_ptr[i] = rec_intradc[i];
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1282 if (s->block_last_index[i] >= 0)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1283 cbp |= 1 << (5 - i);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1284 }
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1285 }else{
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1286 for(i=0; i<6; i++) {
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1287 /* compute cbp */
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1288 if (s->block_last_index[i] >= 1)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1289 cbp |= 1 << (5 - i);
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1290 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1291 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1292
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1293 cbpc = cbp & 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1294 if (s->pict_type == I_TYPE) {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1295 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
1296 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1297 intra_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1298 intra_MCBPC_code[cbpc]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1299 } else {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1300 if(s->dquant) cbpc+=8;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1301 put_bits(&s->pb, 1, 0); /* mb coded */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1302 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1303 inter_MCBPC_bits[cbpc + 4],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1304 inter_MCBPC_code[cbpc + 4]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1305 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1306 if (s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1307 /* XXX: currently, we do not try to use ac prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1308 put_bits(&s->pb, 1, 0); /* no AC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1309 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1310 cbpy = cbp >> 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1311 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1312 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1313 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
1314
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1315 if(interleaved_stats){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1316 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
1317 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1318 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1319
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1320 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
1321 /* encode each block */
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
1322 h263_encode_block(s, block[i], i);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1323
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1324 /* Update INTRADC for decoding */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1325 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
1326 block[i][0] = rec_intradc[i];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1327
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1328 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1329 }
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1330
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1331 if(interleaved_stats){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1332 if (!s->mb_intra) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1333 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
1334 s->f_count++;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1335 }else{
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1336 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
1337 s->i_count++;
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 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1340 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1341 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1342
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
1343 void ff_h263_loop_filter(MpegEncContext * s){
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1344 int qp_c;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1345 const int linesize = s->linesize;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1346 const int uvlinesize= s->uvlinesize;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1347 const int xy = s->mb_y * s->mb_stride + s->mb_x;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1348 uint8_t *dest_y = s->dest[0];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1349 uint8_t *dest_cb= s->dest[1];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1350 uint8_t *dest_cr= s->dest[2];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1351
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1352 // if(s->pict_type==B_TYPE && !s->readable) return;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1353
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1354 /*
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1355 Diag Top
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1356 Left Center
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1357 */
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1358 if(!IS_SKIP(s->current_picture.mb_type[xy])){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1359 qp_c= s->qscale;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1360 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1361 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1362 }else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1363 qp_c= 0;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1364
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1365 if(s->mb_y){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1366 int qp_dt, qp_t, qp_tc;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1367
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1368 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1369 qp_t=0;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1370 else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1371 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1372
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1373 if(qp_c)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1374 qp_tc= qp_c;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1375 else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1376 qp_tc= qp_t;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1377
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1378 if(qp_tc){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1379 const int chroma_qp= s->chroma_qscale_table[qp_tc];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1380 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1381 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1382
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1383 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1384 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1385 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1386
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1387 if(qp_t)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1388 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1389
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1390 if(s->mb_x){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1391 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1392 qp_dt= qp_t;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1393 else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1394 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1395
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1396 if(qp_dt){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1397 const int chroma_qp= s->chroma_qscale_table[qp_dt];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1398 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1399 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
2178
f140ada1f755 copy & paste bug
michael
parents: 2167
diff changeset
1400 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1401 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1402 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1403 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1404
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1405 if(qp_c){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1406 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1407 if(s->mb_y + 1 == s->mb_height)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1408 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1409 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1410
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1411 if(s->mb_x){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1412 int qp_lc;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1413 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1414 qp_lc= qp_c;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1415 else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1416 qp_lc= s->current_picture.qscale_table[xy-1];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1417
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1418 if(qp_lc){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1419 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1420 if(s->mb_y + 1 == s->mb_height){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1421 const int chroma_qp= s->chroma_qscale_table[qp_lc];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1422 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1423 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1424 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1425 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1426 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1427 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1428 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1429
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1430 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1431 {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1432 int x, y, wrap, a, c, pred_dc, scale;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1433 int16_t *dc_val, *ac_val;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1434
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1435 /* find prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1436 if (n < 4) {
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1437 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
1438 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
1439 wrap = s->b8_stride;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1440 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
1441 ac_val = s->ac_val[0][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1442 scale = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1443 } else {
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1444 x = s->mb_x;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1445 y = s->mb_y;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1446 wrap = s->mb_stride;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1447 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
1448 ac_val = s->ac_val[n - 4 + 1][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1449 scale = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1450 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1451 /* B C
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1452 * A X
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1453 */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1454 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
1455 c = dc_val[(x) + (y - 1) * wrap];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1456
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1457 /* 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
1458 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
1459 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
1460 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
1461 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1462 pred_dc = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1463 /* just DC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1464 if (a != 1024 && c != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1465 pred_dc = (a + c) >> 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1466 else if (a != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1467 pred_dc = a;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1468 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1469 pred_dc = c;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1470
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1471 /* we assume pred is positive */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1472 //pred_dc = (pred_dc + (scale >> 1)) / scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1473 *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
1474 return pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1475 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1476
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
1477 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
1478 {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1479 int x, y, wrap, a, c, pred_dc, scale, i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1480 int16_t *dc_val, *ac_val, *ac_val1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1481
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1482 /* find prediction */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1483 if (n < 4) {
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1484 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
1485 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
1486 wrap = s->b8_stride;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1487 dc_val = s->dc_val[0];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1488 ac_val = s->ac_val[0][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1489 scale = s->y_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1490 } else {
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1491 x = s->mb_x;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1492 y = s->mb_y;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1493 wrap = s->mb_stride;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1494 dc_val = s->dc_val[n - 4 + 1];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1495 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
1496 scale = s->c_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1497 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1498
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1499 ac_val += ((y) * wrap + (x)) * 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1500 ac_val1 = ac_val;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1501
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1502 /* B C
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1503 * A X
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1504 */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1505 a = dc_val[(x - 1) + (y) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1506 c = dc_val[(x) + (y - 1) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1507
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1508 /* No prediction outside GOB boundary */
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1509 if(s->first_slice_line && n!=3){
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1510 if(n!=2) c= 1024;
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1511 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1512 }
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1513
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1514 if (s->ac_pred) {
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1515 pred_dc = 1024;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1516 if (s->h263_aic_dir) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1517 /* left prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1518 if (a != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1519 ac_val -= 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1520 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1521 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
1522 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1523 pred_dc = a;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1524 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1525 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1526 /* top prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1527 if (c != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1528 ac_val -= 16 * wrap;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1529 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1530 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
1531 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1532 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1533 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1534 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1535 } else {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1536 /* just DC prediction */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1537 if (a != 1024 && c != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1538 pred_dc = (a + c) >> 1;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1539 else if (a != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1540 pred_dc = a;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1541 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1542 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1543 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1544
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1545 /* we assume pred is positive */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1546 block[0]=block[0]*scale + pred_dc;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1547
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1548 if (block[0] < 0)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1549 block[0] = 0;
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1550 else
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1551 block[0] |= 1;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1552
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1553 /* Update AC/DC tables */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1554 dc_val[(x) + (y) * wrap] = block[0];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1555
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1556 /* left copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1557 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1558 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
1559 /* top copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1560 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1561 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
1562 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1563
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1564 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1565 int *px, int *py)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1566 {
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1567 int wrap;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1568 int16_t *A, *B, *C, (*mot_val)[2];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1569 static const int off[4]= {2, 1, 1, -1};
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1570
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1571 wrap = s->b8_stride;
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
1572 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1573
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1574 A = mot_val[ - 1];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1575 /* special case for first (slice) line */
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1576 if (s->first_slice_line && block<3) {
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1577 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1578 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1579 if(block==0){ //most common case
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1580 if(s->mb_x == s->resync_mb_x){ //rare
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1581 *px= *py = 0;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1582 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1583 C = mot_val[off[block] - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1584 if(s->mb_x==0){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1585 *px = C[0];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1586 *py = C[1];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1587 }else{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1588 *px = mid_pred(A[0], 0, C[0]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1589 *py = mid_pred(A[1], 0, C[1]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1590 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1591 }else{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1592 *px = A[0];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1593 *py = A[1];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1594 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1595 }else if(block==1){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1596 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1597 C = mot_val[off[block] - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1598 *px = mid_pred(A[0], 0, C[0]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1599 *py = mid_pred(A[1], 0, C[1]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1600 }else{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1601 *px = A[0];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1602 *py = A[1];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1603 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1604 }else{ /* block==2*/
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1605 B = mot_val[ - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1606 C = mot_val[off[block] - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1607 if(s->mb_x == s->resync_mb_x) //rare
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1608 A[0]=A[1]=0;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1609
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1610 *px = mid_pred(A[0], B[0], C[0]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1611 *py = mid_pred(A[1], B[1], C[1]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1612 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1613 } else {
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1614 B = mot_val[ - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1615 C = mot_val[off[block] - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1616 *px = mid_pred(A[0], B[0], C[0]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1617 *py = mid_pred(A[1], B[1], C[1]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1618 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1619 return *mot_val;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1620 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1621
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1622 #ifdef CONFIG_ENCODERS
2017
f089d25c82f0 motion estimation for SVQ1
michael
parents: 2004
diff changeset
1623 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1624 {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1625 int range, l, bit_size, sign, code, bits;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1626
986e461dc072 Initial revision
glantau
parents:
diff changeset
1627 if (val == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1628 /* zero vector */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1629 code = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1630 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1631 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1632 bit_size = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1633 range = 1 << bit_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1634 /* modulo encoding */
2093
82816cad0e29 optimization
michael
parents: 2080
diff changeset
1635 l= INT_BIT - 6 - bit_size;
82816cad0e29 optimization
michael
parents: 2080
diff changeset
1636 val = (val<<l)>>l;
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1637 sign = val>>31;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1638 val= (val^sign)-sign;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1639 sign&=1;
2093
82816cad0e29 optimization
michael
parents: 2080
diff changeset
1640
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1641 val--;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1642 code = (val >> bit_size) + 1;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1643 bits = val & (range - 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1644
986e461dc072 Initial revision
glantau
parents:
diff changeset
1645 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1646 if (bit_size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1647 put_bits(&s->pb, bit_size, bits);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1648 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1649 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
1650
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1651 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1652
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1653 /* Encode MV differences on H.263+ with Unrestricted MV mode */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1654 static void h263p_encode_umotion(MpegEncContext * s, int val)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1655 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1656 short sval = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1657 short i = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1658 short n_bits = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1659 short temp_val;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1660 int code = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1661 int tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1662
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1663 if ( val == 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1664 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1665 else if (val == 1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1666 put_bits(&s->pb, 3, 0);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1667 else if (val == -1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1668 put_bits(&s->pb, 3, 2);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1669 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1670
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1671 sval = ((val < 0) ? (short)(-val):(short)val);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1672 temp_val = sval;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1673
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1674 while (temp_val != 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1675 temp_val = temp_val >> 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1676 n_bits++;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1677 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1678
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1679 i = n_bits - 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1680 while (i > 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1681 tcode = (sval & (1 << (i-1))) >> (i-1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1682 tcode = (tcode << 1) | 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1683 code = (code << 2) | tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1684 i--;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1685 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1686 code = ((code << 1) | (val < 0)) << 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1687 put_bits(&s->pb, (2*n_bits)+1, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1688 //printf("\nVal = %d\tCode = %d", sval, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1689 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1690 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1691
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1692 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
1693 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1694 int f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1695 int mv;
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1696
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1697 if(mv_penalty==NULL)
1162
8c15d82c1893 some static -> dynamic alloc & 16->8 bit
michaelni
parents: 1150
diff changeset
1698 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1699
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1700 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
1701 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
1702 int len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1703
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1704 if(mv==0) len= mvtab[0][1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1705 else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1706 int val, bit_size, range, code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1707
1893
779bdf5063ce 1000000l (using uninitalized variable for initalizing bits per MV table)
michael
parents: 1873
diff changeset
1708 bit_size = f_code - 1;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1709 range = 1 << bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1710
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1711 val=mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1712 if (val < 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1713 val = -val;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1714 val--;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1715 code = (val >> bit_size) + 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1716 if(code<33){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1717 len= mvtab[code][1] + 1 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1718 }else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1719 len= mvtab[32][1] + 2 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1720 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1721 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1722
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1723 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
1724 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1725 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1726
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1727 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
1728 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
1729 fcode_tab[mv+MAX_MV]= f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1730 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1731 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1732
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1733 for(mv=0; mv<MAX_MV*2+1; mv++){
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1734 umv_fcode_tab[mv]= 1;
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1735 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1736 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1737 #endif
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1738
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
1739 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1740
468
1e23eae32087 Minor warning cleanup.
mellum
parents: 453
diff changeset
1741 static void init_uni_dc_tab(void)
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1742 {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1743 int level, uni_code, uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1744
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1745 for(level=-256; level<256; level++){
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1746 int size, v, l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1747 /* find number of bits */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1748 size = 0;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1749 v = abs(level);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1750 while (v) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1751 v >>= 1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1752 size++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1753 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1754
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1755 if (level < 0)
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1756 l= (-level) ^ ((1 << size) - 1);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1757 else
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1758 l= level;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1759
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1760 /* luminance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1761 uni_code= DCtab_lum[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1762 uni_len = DCtab_lum[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1763
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1764 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1765 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1766 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1767 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1768 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1769 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1770 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1771 }
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1772 uni_DCtab_lum_bits[level+256]= uni_code;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1773 uni_DCtab_lum_len [level+256]= uni_len;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1774
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1775 /* chrominance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1776 uni_code= DCtab_chrom[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1777 uni_len = DCtab_chrom[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1778
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1779 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1780 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1781 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1782 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1783 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1784 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1785 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1786 }
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1787 uni_DCtab_chrom_bits[level+256]= uni_code;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1788 uni_DCtab_chrom_len [level+256]= uni_len;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1789
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1790 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1791 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1792
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
1793 #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
1794
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1795 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1796 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
1797 int slevel, run, last;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1798
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1799 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
1800 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
1801
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1802 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
1803 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
1804 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
1805 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
1806 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
1807 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
1808 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
1809 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
1810 int level1, run1;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1811
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1812 len_tab[index]= 100;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1813
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1814 /* 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
1815 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
1816 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
1817 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
1818 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1819
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1820 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
1821 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
1822 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
1823 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1824 #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
1825 /* 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
1826 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
1827 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
1828 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
1829 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
1830 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
1831 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
1832 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
1833 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
1834 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
1835 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1836
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1837 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
1838 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
1839 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
1840 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1841 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1842 #endif
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1843 #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
1844 /* 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
1845 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
1846 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
1847 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
1848 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
1849 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
1850 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
1851 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
1852 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
1853 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
1854 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1855
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1856 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
1857 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
1858 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
1859 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1860 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1861 #endif
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1862 /* 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
1863 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
1864 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
1865 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
1866 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
1867 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
1868 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
1869 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
1870 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
1871
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1872 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
1873 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
1874 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
1875 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1876 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1877 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1878 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1879 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1880
2253
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1881 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1882 int slevel, run, last;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1883
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1884 assert(MAX_LEVEL >= 64);
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1885 assert(MAX_RUN >= 63);
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1886
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1887 for(slevel=-64; slevel<64; slevel++){
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1888 if(slevel==0) continue;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1889 for(run=0; run<64; run++){
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1890 for(last=0; last<=1; last++){
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1891 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1892 int level= slevel < 0 ? -slevel : slevel;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1893 int sign= slevel < 0 ? 1 : 0;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1894 int bits, len, code;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1895 int level1, run1;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1896
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1897 len_tab[index]= 100;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1898
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1899 /* ESC0 */
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1900 code= get_rl_index(rl, last, run, level);
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1901 bits= rl->table_vlc[code][0];
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1902 len= rl->table_vlc[code][1];
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1903 bits=bits*2+sign; len++;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1904
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1905 if(code!=rl->n && len < len_tab[index]){
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1906 if(bits_tab) bits_tab[index]= bits;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1907 len_tab [index]= len;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1908 }
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1909 /* ESC */
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1910 bits= rl->table_vlc[rl->n][0];
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1911 len = rl->table_vlc[rl->n][1];
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1912 bits=bits*2+last; len++;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1913 bits=bits*64+run; len+=6;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1914 bits=bits*256+(level&0xff); len+=8;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1915
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1916 if(len < len_tab[index]){
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1917 if(bits_tab) bits_tab[index]= bits;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1918 len_tab [index]= len;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1919 }
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1920 }
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1921 }
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1922 }
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1923 }
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1924
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1925 void h263_encode_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1926 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1927 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1928
986e461dc072 Initial revision
glantau
parents:
diff changeset
1929 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1930 done = 1;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1931
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1932 init_uni_dc_tab();
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1933
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
1934 init_rl(&rl_inter, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
1935 init_rl(&rl_intra, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
1936 init_rl(&rl_intra_aic, 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
1937
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1939 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
1940
2253
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1941 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1942 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1943
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1944 init_mv_penalty_and_fcode(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1945 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1946 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1947
2253
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1948 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1949 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1950 if(s->h263_aic){
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1951 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1952 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1953 }
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1954 s->ac_esc_length= 7+1+6+8;
1085c5284bf1 trellis quantization for h263(p)
michael
parents: 2243
diff changeset
1955
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1956 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1957 switch(s->codec_id){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1958 case CODEC_ID_MPEG4:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1959 s->fcode_tab= fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1960 s->min_qcoeff= -2048;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1961 s->max_qcoeff= 2047;
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1962 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1963 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1964 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1965 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1966 s->luma_dc_vlc_length= uni_DCtab_lum_len;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1967 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1968 s->ac_esc_length= 7+2+1+6+1+12+1;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
1969 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
1970 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
1971
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1972 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1483
michaelni
parents: 1482
diff changeset
1973
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1974 s->avctx->extradata= av_malloc(1024);
1522
79dddc5cd990 removed the obsolete and unused parameters of init_put_bits
alex
parents: 1521
diff changeset
1975 init_put_bits(&s->pb, s->avctx->extradata, 1024);
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1976
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1977 mpeg4_encode_visual_object_header(s);
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1978 mpeg4_encode_vol_header(s, 0, 0);
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1979
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1980 // ff_mpeg4_stuffing(&s->pb); ?
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1981 flush_put_bits(&s->pb);
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1773
diff changeset
1982 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1983 }
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1984
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1985 break;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1986 case CODEC_ID_H263P:
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1987 if(s->umvplus)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1988 s->fcode_tab= umv_fcode_tab;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1989 if(s->modified_quant){
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1990 s->min_qcoeff= -2047;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1991 s->max_qcoeff= 2047;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1992 }else{
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1993 s->min_qcoeff= -127;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1994 s->max_qcoeff= 127;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1995 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1996 break;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1997 //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
1998 case CODEC_ID_FLV1:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1999 if (s->h263_flv > 1) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2000 s->min_qcoeff= -1023;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2001 s->max_qcoeff= 1023;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2002 } else {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2003 s->min_qcoeff= -127;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2004 s->max_qcoeff= 127;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2005 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2006 s->y_dc_scale_table=
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2007 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
2008 break;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2009 default: //nothing needed default table allready set in mpegvideo.c
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2010 s->min_qcoeff= -127;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2011 s->max_qcoeff= 127;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
2012 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
2013 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2014 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2015 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2016
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2017 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2018 * encodes a 8x8 block.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2019 * @param block the 8x8 block
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2020 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2021 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2022 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2023 {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2024 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
2025 RLTable *rl;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2026
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2027 rl = &rl_inter;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2028 if (s->mb_intra && !s->h263_aic) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2029 /* DC coef */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2030 level = block[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2031 /* 255 cannot be represented, so we clamp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2032 if (level > 254) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2033 level = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2034 block[0] = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2035 }
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2036 /* 0 cannot be represented also */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2037 else if (level < 1) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2038 level = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2039 block[0] = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2040 }
1090
michaelni
parents: 1089
diff changeset
2041 if (level == 128) //FIXME check rv10
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2042 put_bits(&s->pb, 8, 0xff);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2043 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
2044 put_bits(&s->pb, 8, level);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2045 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2046 } else {
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2047 i = 0;
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2048 if (s->h263_aic && s->mb_intra)
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2049 rl = &rl_intra_aic;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2050
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2051 if(s->alt_inter_vlc && !s->mb_intra){
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2052 int aic_vlc_bits=0;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2053 int inter_vlc_bits=0;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2054 int wrong_pos=-1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2055 int aic_code;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2056
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2057 last_index = s->block_last_index[n];
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2058 last_non_zero = i - 1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2059 for (; i <= last_index; i++) {
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2060 j = s->intra_scantable.permutated[i];
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2061 level = block[j];
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2062 if (level) {
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2063 run = i - last_non_zero - 1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2064 last = (i == last_index);
1663
4ac3573977e6 alternative inter vlc encoding fix
michael
parents: 1661
diff changeset
2065
4ac3573977e6 alternative inter vlc encoding fix
michael
parents: 1661
diff changeset
2066 if(level<0) level= -level;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2067
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2068 code = get_rl_index(rl, last, run, level);
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2069 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2070 inter_vlc_bits += rl->table_vlc[code][1]+1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2071 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2072
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2073 if (code == rl->n) {
1663
4ac3573977e6 alternative inter vlc encoding fix
michael
parents: 1661
diff changeset
2074 inter_vlc_bits += 1+6+8-1;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2075 }
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2076 if (aic_code == rl_intra_aic.n) {
1663
4ac3573977e6 alternative inter vlc encoding fix
michael
parents: 1661
diff changeset
2077 aic_vlc_bits += 1+6+8-1;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2078 wrong_pos += run + 1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2079 }else
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2080 wrong_pos += wrong_run[aic_code];
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2081 last_non_zero = i;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2082 }
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2083 }
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2084 i = 0;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2085 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2086 rl = &rl_intra_aic;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2087 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2088 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2089
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2090 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2091 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2092 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2093 for (; i <= last_index; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
2094 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
2095 level = block[j];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2096 if (level) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2097 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
2098 last = (i == last_index);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2099 sign = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2100 slevel = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2101 if (level < 0) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2102 sign = 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2103 level = -level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2104 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2105 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2106 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2107 if (code == rl->n) {
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2108 if(s->h263_flv <= 1){
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2109 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2110 put_bits(&s->pb, 6, run);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2111
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2112 assert(slevel != 0);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2113
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
2114 if(level < 128)
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2115 put_bits(&s->pb, 8, slevel & 0xff);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2116 else{
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2117 put_bits(&s->pb, 8, 128);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2118 put_bits(&s->pb, 5, slevel & 0x1f);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2119 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2120 }
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2121 }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
2122 if(level < 64) { // 7-bit level
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2123 put_bits(&s->pb, 1, 0);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2124 put_bits(&s->pb, 1, last);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2125 put_bits(&s->pb, 6, run);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2126
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2127 put_bits(&s->pb, 7, slevel & 0x7f);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2128 } else {
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2129 /* 11-bit level */
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2130 put_bits(&s->pb, 1, 1);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2131 put_bits(&s->pb, 1, last);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2132 put_bits(&s->pb, 6, run);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2133
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2134 put_bits(&s->pb, 11, slevel & 0x7ff);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2135 }
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2136 }
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2137 } else {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2138 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
2139 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2140 last_non_zero = i;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2141 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2142 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2143 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
2144 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2145
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
2146 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2147
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2148 /***************************************************/
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2149 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2150 * add mpeg4 stuffing bits (01...1)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2151 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2152 void ff_mpeg4_stuffing(PutBitContext * pbc)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2153 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2154 int length;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2155 put_bits(pbc, 1, 0);
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1773
diff changeset
2156 length= (-put_bits_count(pbc))&7;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2157 if(length) put_bits(pbc, length, (1<<length)-1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2158 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2159
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2160 /* must be called before writing the header */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2161 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2162 int time_div, time_mod;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2163
1831
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
2164 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
2165 s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
1829
7ae26b6e197f set AVFrame.pts based upon framerate if its 0
michael
parents: 1799
diff changeset
2166
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2167 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2168 time_mod= s->time%s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2169
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2170 if(s->pict_type==B_TYPE){
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
2171 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
2243
b8bad8bbbc64 check if the user specified timestamps are strictly monotone
michael
parents: 2204
diff changeset
2172 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2173 }else{
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2174 s->last_time_base= s->time_base;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2175 s->time_base= time_div;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2176 s->pp_time= s->time - s->last_non_b_time;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2177 s->last_non_b_time= s->time;
2243
b8bad8bbbc64 check if the user specified timestamps are strictly monotone
michael
parents: 2204
diff changeset
2178 assert(s->pp_time > 0);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2179 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2180 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2181
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2182 static void mpeg4_encode_gop_header(MpegEncContext * s){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2183 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
2184 int64_t time;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2185
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2186 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2187 put_bits(&s->pb, 16, GOP_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2188
1831
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
2189 time= s->current_picture_ptr->pts;
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
2190 if(s->reordered_input_picture[1])
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
2191 time= FFMIN(time, s->reordered_input_picture[1]->pts);
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
2192 time= (time*s->time_increment_resolution + AV_TIME_BASE/2)/AV_TIME_BASE;
1763
951403db901f first coded vs. first displayed pts (segfault & pts fix if b frames are used)
michael
parents: 1760
diff changeset
2193
951403db901f first coded vs. first displayed pts (segfault & pts fix if b frames are used)
michael
parents: 1760
diff changeset
2194 seconds= time/s->time_increment_resolution;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2195 minutes= seconds/60; seconds %= 60;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2196 hours= minutes/60; minutes %= 60;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2197 hours%=24;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2198
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2199 put_bits(&s->pb, 5, hours);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2200 put_bits(&s->pb, 6, minutes);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2201 put_bits(&s->pb, 1, 1);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2202 put_bits(&s->pb, 6, seconds);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2203
1760
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
2204 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2205 put_bits(&s->pb, 1, 0); //broken link == NO
1760
ebe7fa49ddcc mpeg4 pts fix
michael
parents: 1757
diff changeset
2206
1763
951403db901f first coded vs. first displayed pts (segfault & pts fix if b frames are used)
michael
parents: 1760
diff changeset
2207 s->last_time_base= time / s->time_increment_resolution;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2208
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2209 ff_mpeg4_stuffing(&s->pb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2210 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2211
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2212 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2213 int profile_and_level_indication;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2214 int vo_ver_id;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2215
2167
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2216 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2217 profile_and_level_indication = s->avctx->profile << 4;
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2218 }else if(s->max_b_frames || s->quarter_sample){
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2219 profile_and_level_indication= 0xF0; // adv simple
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2220 }else{
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2221 profile_and_level_indication= 0x00; // simple
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2222 }
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2223
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2224 if(s->avctx->level != FF_LEVEL_UNKNOWN){
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2225 profile_and_level_indication |= s->avctx->level;
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2226 }else{
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2227 profile_and_level_indication |= 1; //level 1
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2228 }
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2229
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2230 if(profile_and_level_indication>>4 == 0xF){
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2231 vo_ver_id= 5;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2232 }else{
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2233 vo_ver_id= 1;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2234 }
2167
76334bbb5038 user overrideable level & profile
michael
parents: 2093
diff changeset
2235
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2236 //FIXME levels
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2237
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2238 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2239 put_bits(&s->pb, 16, VOS_STARTCODE);
1350
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2240
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2241 put_bits(&s->pb, 8, profile_and_level_indication);
1350
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2242
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2243 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2244 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2245
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2246 put_bits(&s->pb, 1, 1);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2247 put_bits(&s->pb, 4, vo_ver_id);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2248 put_bits(&s->pb, 3, 1); //priority
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2249
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2250 put_bits(&s->pb, 4, 1); //visual obj type== video obj
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2251
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2252 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2253
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2254 ff_mpeg4_stuffing(&s->pb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2255 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2256
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2257 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2258 {
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2259 int vo_ver_id;
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2260
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2261 if(s->max_b_frames || s->quarter_sample){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2262 vo_ver_id= 5;
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
2263 s->vo_type= ADV_SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
2264 }else{
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2265 vo_ver_id= 1;
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
2266 s->vo_type= SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
2267 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2268
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2269 put_bits(&s->pb, 16, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2270 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2271 put_bits(&s->pb, 16, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2272 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2273
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2274 put_bits(&s->pb, 1, 0); /* random access vol */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2275 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2276 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2277 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2278 put_bits(&s->pb, 3, 1); /* is obj layer priority */
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
2279
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
2280 aspect_to_info(s, s->avctx->sample_aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
2281
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
2282 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
2283 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
2284 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
2285 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
2286 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2287
2204
4f8da6a9e6eb Always write VOL control parameters, needed by old xvid patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents: 2178
diff changeset
2288 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
4f8da6a9e6eb Always write VOL control parameters, needed by old xvid patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents: 2178
diff changeset
2289 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
4f8da6a9e6eb Always write VOL control parameters, needed by old xvid patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents: 2178
diff changeset
2290 put_bits(&s->pb, 1, s->low_delay);
4f8da6a9e6eb Always write VOL control parameters, needed by old xvid patch by (Loren Merritt <lorenm at u dot washington dot edu>)
michael
parents: 2178
diff changeset
2291 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2292
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2293 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2294 put_bits(&s->pb, 1, 1); /* marker bit */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2295
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2296 put_bits(&s->pb, 16, s->time_increment_resolution);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2297 if (s->time_increment_bits < 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2298 s->time_increment_bits = 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2299 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2300 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2301 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2302 put_bits(&s->pb, 13, s->width); /* vol width */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2303 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2304 put_bits(&s->pb, 13, s->height); /* vol height */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2305 put_bits(&s->pb, 1, 1); /* marker bit */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2306 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2307 put_bits(&s->pb, 1, 1); /* obmc disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2308 if (vo_ver_id == 1) {
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
2309 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2310 }else{
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
2311 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2312 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2313
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2314 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
2315 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2316
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2317 if(s->mpeg_quant){
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2318 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2319 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2320 }
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
2321
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2322 if (vo_ver_id != 1)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2323 put_bits(&s->pb, 1, s->quarter_sample);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2324 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2325 s->resync_marker= s->rtp_mode;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2326 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2327 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2328 if(s->data_partitioning){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2329 put_bits(&s->pb, 1, 0); /* no rvlc */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2330 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2331
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2332 if (vo_ver_id != 1){
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2333 put_bits(&s->pb, 1, 0); /* newpred */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2334 put_bits(&s->pb, 1, 0); /* reduced res vop */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2335 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2336 put_bits(&s->pb, 1, 0); /* scalability */
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2337
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2338 ff_mpeg4_stuffing(&s->pb);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2339
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2340 /* user data */
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2341 if(!(s->flags & CODEC_FLAG_BITEXACT)){
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2342 put_bits(&s->pb, 16, 0);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2343 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1795
920e6381e1fe 2 byte shorter userdata for mpeg4
michael
parents: 1789
diff changeset
2344 put_string(&s->pb, LIBAVCODEC_IDENT, 0);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2345 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2346 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2347
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2348 /* write mpeg4 VOP header */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2349 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2350 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2351 int time_incr;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2352 int time_div, time_mod;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2353
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2354 if(s->pict_type==I_TYPE){
953
9eb066d6e0db mpeg4 header encoding bugfix
michaelni
parents: 945
diff changeset
2355 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1350
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2356 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2357 mpeg4_encode_visual_object_header(s);
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2358 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2359 mpeg4_encode_vol_header(s, 0, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2360 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2361 mpeg4_encode_gop_header(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2362 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2363
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2364 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2365
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2366 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2367
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
2368 put_bits(&s->pb, 16, 0); /* vop header */
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2369 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2370 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2371
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2372 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2373 time_mod= s->time%s->time_increment_resolution;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2374 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
2375 assert(time_incr >= 0);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2376 while(time_incr--)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2377 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2378
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2379 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2380
986e461dc072 Initial revision
glantau
parents:
diff changeset
2381 put_bits(&s->pb, 1, 1); /* marker */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2382 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2383 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2384 put_bits(&s->pb, 1, 1); /* vop coded */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2385 if ( s->pict_type == P_TYPE
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2386 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2387 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2388 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2389 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2390 if(!s->progressive_sequence){
1659
3075fc11a974 AVFrame.interlaced_frame fixes
michael
parents: 1656
diff changeset
2391 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2392 put_bits(&s->pb, 1, s->alternate_scan);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2393 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2394 //FIXME sprite stuff
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2395
986e461dc072 Initial revision
glantau
parents:
diff changeset
2396 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2397
986e461dc072 Initial revision
glantau
parents:
diff changeset
2398 if (s->pict_type != I_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2399 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2400 if (s->pict_type == B_TYPE)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2401 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2402 // printf("****frame %d\n", picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2403 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2404
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
2405 #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
2406
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2407 /**
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
2408 * set qscale and update qscale dependant variables.
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2409 */
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
2410 void ff_set_qscale(MpegEncContext * s, int qscale)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2411 {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
2412 if (qscale < 1)
834922115010 cleanup
michael
parents: 1649
diff changeset
2413 qscale = 1;
834922115010 cleanup
michael
parents: 1649
diff changeset
2414 else if (qscale > 31)
834922115010 cleanup
michael
parents: 1649
diff changeset
2415 qscale = 31;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
2416
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
2417 s->qscale = qscale;
834922115010 cleanup
michael
parents: 1649
diff changeset
2418 s->chroma_qscale= s->chroma_qscale_table[qscale];
834922115010 cleanup
michael
parents: 1649
diff changeset
2419
834922115010 cleanup
michael
parents: 1649
diff changeset
2420 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
2421 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2422 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2423
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2424 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2425 * predicts the dc.
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2426 * encoding quantized level -> quantized diff
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2427 * decoding quantized diff -> quantized level
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2428 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2429 * @param dir_ptr pointer to an integer where the prediction direction will be stored
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2430 */
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2431 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2432 {
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2433 int a, b, c, wrap, pred, scale, ret;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2434 uint16_t *dc_val;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2435
986e461dc072 Initial revision
glantau
parents:
diff changeset
2436 /* find prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2437 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2438 scale = s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2439 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2440 scale = s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2441 }
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
2442 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
2443 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
2444
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2445 wrap= s->block_wrap[n];
252444e5259b optimization
michaelni
parents: 265
diff changeset
2446 dc_val = s->dc_val[0] + s->block_index[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2447
986e461dc072 Initial revision
glantau
parents:
diff changeset
2448 /* B C
986e461dc072 Initial revision
glantau
parents:
diff changeset
2449 * A X
986e461dc072 Initial revision
glantau
parents:
diff changeset
2450 */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2451 a = dc_val[ - 1];
252444e5259b optimization
michaelni
parents: 265
diff changeset
2452 b = dc_val[ - 1 - wrap];
252444e5259b optimization
michaelni
parents: 265
diff changeset
2453 c = dc_val[ - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2454
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2455 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2456 if(s->first_slice_line && n!=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2457 if(n!=2) b=c= 1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2458 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
2459 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2460 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
2461 if(n==0 || n==4 || n==5)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2462 b=1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2463 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2464
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2465 if (abs(a - b) < abs(b - c)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2466 pred = c;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2467 *dir_ptr = 1; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2468 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2469 pred = a;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2470 *dir_ptr = 0; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2471 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2472 /* 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
2473 pred = FASTDIV((pred + (scale >> 1)), scale);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2474
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2475 if(encoding){
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2476 ret = level - pred;
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2477 }else{
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2478 level += pred;
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2479 ret= level;
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2480 if(s->error_resilience>=3){
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2481 if(level<0){
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2482 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2483 return -1;
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2484 }
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2485 if(level*scale > 2048 + scale){
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2486 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2487 return -1;
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2488 }
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2489 }
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2490 }
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2491 level *=scale;
2004
ec6bfd8d92fc support decoding mpeg4 with buggy dc clipping
michael
parents: 2003
diff changeset
2492 if(level&(~2047)){
ec6bfd8d92fc support decoding mpeg4 with buggy dc clipping
michael
parents: 2003
diff changeset
2493 if(level<0)
ec6bfd8d92fc support decoding mpeg4 with buggy dc clipping
michael
parents: 2003
diff changeset
2494 level=0;
ec6bfd8d92fc support decoding mpeg4 with buggy dc clipping
michael
parents: 2003
diff changeset
2495 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
ec6bfd8d92fc support decoding mpeg4 with buggy dc clipping
michael
parents: 2003
diff changeset
2496 level=2047;
ec6bfd8d92fc support decoding mpeg4 with buggy dc clipping
michael
parents: 2003
diff changeset
2497 }
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2498 dc_val[0]= level;
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2499
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
2500 return ret;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2501 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2502
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2503 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2504 * predicts the ac.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2505 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2506 * @param dir the ac prediction direction
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2507 */
1008
fb6cbb8a04a3 fixing DCTELEM != short
michaelni
parents: 999
diff changeset
2508 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2509 int dir)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2510 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2511 int i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2512 int16_t *ac_val, *ac_val1;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2513 int8_t * const qscale_table= s->current_picture.qscale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2514
986e461dc072 Initial revision
glantau
parents:
diff changeset
2515 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2516 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2517 ac_val1 = ac_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2518 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2519 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
2520 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2521 /* left prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2522 ac_val -= 16;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2523
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2524 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2525 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2526 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2527 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2528 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2529 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2530 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2531 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2532 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2533 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2534 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2535 } 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
2536 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2537 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2538 ac_val -= 16 * s->block_wrap[n];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2539
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2540 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2541 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2542 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2543 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2544 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2545 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2546 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2547 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2548 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2549 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2550 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2551 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2552 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2553 /* left copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2554 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2555 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
2556
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2557 /* top copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2558 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2559 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
2560
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2561 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2562
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
2563 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2564
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2565 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2566 * encodes the dc value.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2567 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2568 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2569 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
2570 {
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2571 #if 1
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2572 // if(level<-255 || level>255) printf("dc overflow\n");
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2573 level+=256;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2574 if (n < 4) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2575 /* luminance */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
2576 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2577 } else {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2578 /* chrominance */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
2579 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2580 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2581 #else
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
2582 int size, v;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2583 /* find number of bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2584 size = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2585 v = abs(level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2586 while (v) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2587 v >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2588 size++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2589 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2590
986e461dc072 Initial revision
glantau
parents:
diff changeset
2591 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2592 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2593 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2594 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2595 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2596 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2597 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2598
986e461dc072 Initial revision
glantau
parents:
diff changeset
2599 /* encode remaining bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2600 if (size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2601 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2602 level = (-level) ^ ((1 << size) - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2603 put_bits(&s->pb, size, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2604 if (size > 8)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2605 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2606 }
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2607 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2608 }
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
2609
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2610 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2611 * encodes a 8x8 block
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2612 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2613 */
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
2614 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2615 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2616 {
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2617 int i, last_non_zero;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2618 #if 0 //variables for the outcommented version
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2619 int code, sign, last;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2620 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2621 const RLTable *rl;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2622 uint32_t *bits_tab;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2623 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
2624 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
2625
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2626 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2627 /* mpeg4 based DC predictor */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2628 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
2629 if(last_index<1) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2630 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2631 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
2632 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
2633 len_tab = uni_mpeg4_intra_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2634 } 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
2635 if(last_index<0) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2636 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2637 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
2638 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
2639 len_tab = uni_mpeg4_inter_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2640 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2641
986e461dc072 Initial revision
glantau
parents:
diff changeset
2642 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2643 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
2644 #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
2645 for (; i < last_index; i++) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2646 int level = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2647 if (level) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2648 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
2649 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
2650 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
2651 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
2652 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
2653 }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
2654 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
2655 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2656 last_non_zero = i;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2657 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2658 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2659 /*if(i<=last_index)*/{
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2660 int level = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2661 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
2662 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
2663 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
2664 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
2665 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
2666 }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
2667 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
2668 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2669 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2670 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2671 for (; i <= last_index; i++) {
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2672 const int slevel = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2673 if (slevel) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2674 int level;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2675 int run = i - last_non_zero - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2676 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2677 sign = 0;
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2678 level = slevel;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2679 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2680 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2681 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2682 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2683 code = get_rl_index(rl, last, run, level);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2684 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2685 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2686 int level1, run1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2687 level1 = level - rl->max_level[last][run];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2688 if (level1 < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2689 goto esc2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2690 code = get_rl_index(rl, last, run, level1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2691 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2692 esc2:
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2693 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2694 if (level > MAX_LEVEL)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2695 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2696 run1 = run - rl->max_run[last][level] - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2697 if (run1 < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2698 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2699 code = get_rl_index(rl, last, run1, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2700 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2701 esc3:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2702 /* third escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2703 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2704 put_bits(ac_pb, 1, last);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2705 put_bits(ac_pb, 6, run);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2706 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2707 put_bits(ac_pb, 12, slevel & 0xfff);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2708 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2709 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2710 /* second escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2711 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2712 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2713 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2714 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2715 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2716 /* first escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2717 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2718 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2719 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2720 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2721 } else {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2722 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2723 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2724 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2725 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2726 }
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
2727 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2728 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2729
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2730 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2731 uint8_t *scan_table)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2732 {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2733 int i, last_non_zero;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2734 const RLTable *rl;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2735 uint8_t *len_tab;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2736 const int last_index = s->block_last_index[n];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2737 int len=0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2738
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2739 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2740 /* mpeg4 based DC predictor */
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2741 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2742 if(last_index<1) return len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2743 i = 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2744 rl = &rl_intra;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2745 len_tab = uni_mpeg4_intra_rl_len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2746 } else {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2747 if(last_index<0) return 0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2748 i = 0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2749 rl = &rl_inter;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2750 len_tab = uni_mpeg4_inter_rl_len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2751 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2752
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2753 /* AC coefs */
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2754 last_non_zero = i - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2755 for (; i < last_index; i++) {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2756 int level = block[ scan_table[i] ];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2757 if (level) {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2758 int run = i - last_non_zero - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2759 level+=64;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2760 if((level&(~127)) == 0){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2761 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2762 len += len_tab[index];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2763 }else{ //ESC3
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2764 len += 7+2+1+6+1+12+1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2765 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2766 last_non_zero = i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2767 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2768 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2769 /*if(i<=last_index)*/{
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2770 int level = block[ scan_table[i] ];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2771 int run = i - last_non_zero - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2772 level+=64;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2773 if((level&(~127)) == 0){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2774 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2775 len += len_tab[index];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2776 }else{ //ESC3
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2777 len += 7+2+1+6+1+12+1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2778 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2779 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2780
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2781 return len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2782 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2783
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
2784 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2785
986e461dc072 Initial revision
glantau
parents:
diff changeset
2786
986e461dc072 Initial revision
glantau
parents:
diff changeset
2787 /***********************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
2788 /* decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2789
986e461dc072 Initial revision
glantau
parents:
diff changeset
2790 static VLC intra_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2791 static VLC inter_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2792 static VLC cbpy_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2793 static VLC mv_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2794 static VLC dc_lum, dc_chrom;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2795 static VLC sprite_trajectory;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2796 static VLC mb_type_b_vlc;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2797 static VLC h263_mbtype_b_vlc;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2798 static VLC cbpc_b_vlc;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2799
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2800 void init_vlc_rl(RLTable *rl, int use_static)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2801 {
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2802 int i, q;
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2803
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2804 /* Return if static table is already initialized */
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2805 if(use_static && rl->rl_vlc[0])
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2806 return;
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2807
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2808 init_vlc(&rl->vlc, 9, rl->n + 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2809 &rl->table_vlc[0][1], 4, 2,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2810 &rl->table_vlc[0][0], 4, 2, use_static);
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2811
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2812
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2813 for(q=0; q<32; q++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2814 int qmul= q*2;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2815 int qadd= (q-1)|1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2816
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2817 if(q==0){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2818 qmul=1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2819 qadd=0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2820 }
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2821 if(use_static)
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2822 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2823 else
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2824 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2825 for(i=0; i<rl->vlc.table_size; i++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2826 int code= rl->vlc.table[i][0];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2827 int len = rl->vlc.table[i][1];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2828 int level, run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2829
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2830 if(len==0){ // illegal code
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2831 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2832 level= MAX_LEVEL;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2833 }else if(len<0){ //more bits needed
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2834 run= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2835 level= code;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2836 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2837 if(code==rl->n){ //esc
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2838 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2839 level= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2840 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2841 run= rl->table_run [code] + 1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2842 level= rl->table_level[code] * qmul + qadd;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2843 if(code >= rl->last) run+=192;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2844 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2845 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2846 rl->rl_vlc[q][i].len= len;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2847 rl->rl_vlc[q][i].level= level;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2848 rl->rl_vlc[q][i].run= run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2849 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2850 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2851 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2852
986e461dc072 Initial revision
glantau
parents:
diff changeset
2853 /* init vlcs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2854
986e461dc072 Initial revision
glantau
parents:
diff changeset
2855 /* XXX: find a better solution to handle static init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2856 void h263_decode_init_vlc(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2857 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2858 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2859
986e461dc072 Initial revision
glantau
parents:
diff changeset
2860 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2861 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2862
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
2863 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2864 intra_MCBPC_bits, 1, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2865 intra_MCBPC_code, 1, 1, 1);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
2866 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2867 inter_MCBPC_bits, 1, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2868 inter_MCBPC_code, 1, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2869 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2870 &cbpy_tab[0][1], 2, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2871 &cbpy_tab[0][0], 2, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2872 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2873 &mvtab[0][1], 2, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2874 &mvtab[0][0], 2, 1, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2875 init_rl(&rl_inter, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2876 init_rl(&rl_intra, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2877 init_rl(&rvlc_rl_inter, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2878 init_rl(&rvlc_rl_intra, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2879 init_rl(&rl_intra_aic, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2880 init_vlc_rl(&rl_inter, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2881 init_vlc_rl(&rl_intra, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2882 init_vlc_rl(&rvlc_rl_inter, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2883 init_vlc_rl(&rvlc_rl_intra, 1);
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2884 init_vlc_rl(&rl_intra_aic, 1);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2885 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2886 &DCtab_lum[0][1], 2, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2887 &DCtab_lum[0][0], 2, 1, 1);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2888 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2889 &DCtab_chrom[0][1], 2, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2890 &DCtab_chrom[0][0], 2, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2891 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2892 &sprite_trajectory_tab[0][1], 4, 2,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2893 &sprite_trajectory_tab[0][0], 4, 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2894 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2895 &mb_type_b_tab[0][1], 2, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2896 &mb_type_b_tab[0][0], 2, 1, 1);
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2897 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2898 &h263_mbtype_b_tab[0][1], 2, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2899 &h263_mbtype_b_tab[0][0], 2, 1, 1);
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2900 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2901 &cbpc_b_tab[0][1], 2, 1,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2271
diff changeset
2902 &cbpc_b_tab[0][0], 2, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2903 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2904 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2905
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2906 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2907 * 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
2908 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2909 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
2910 if (s->height <= 400)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2911 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2912 else if (s->height <= 800)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2913 return 2;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2914 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2915 return 4;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2916 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2917
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2918 int ff_h263_decode_mba(MpegEncContext *s)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2919 {
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2920 int i, mb_pos;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2921
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2922 for(i=0; i<6; i++){
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
2923 if(s->mb_num-1 <= ff_mba_max[i]) break;
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2924 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2925 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2926 s->mb_x= mb_pos % s->mb_width;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2927 s->mb_y= mb_pos / s->mb_width;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2928
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2929 return mb_pos;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2930 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2931
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2932 void ff_h263_encode_mba(MpegEncContext *s)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2933 {
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2934 int i, mb_pos;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2935
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2936 for(i=0; i<6; i++){
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
2937 if(s->mb_num-1 <= ff_mba_max[i]) break;
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2938 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2939 mb_pos= s->mb_x + s->mb_width*s->mb_y;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2940 put_bits(&s->pb, ff_mba_length[i], mb_pos);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2941 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2942
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2943 /**
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2944 * decodes the group of blocks header or slice header.
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2945 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2946 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2947 static int h263_decode_gob_header(MpegEncContext *s)
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2948 {
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2949 unsigned int val, gfid, gob_number;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2950 int left;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2951
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2952 /* Check for GOB Start Code */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2953 val = show_bits(&s->gb, 16);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2954 if(val)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2955 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2956
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2957 /* 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
2958 skip_bits(&s->gb, 16); /* Drop the zeros */
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
2959 left= s->gb.size_in_bits - get_bits_count(&s->gb);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2960 //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
2961 for(;left>13; left--){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2962 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
2963 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2964 if(left<=13)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2965 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2966
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2967 if(s->h263_slice_structured){
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2968 if(get_bits1(&s->gb)==0)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2969 return -1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2970
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2971 ff_h263_decode_mba(s);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2972
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2973 if(s->mb_num > 1583)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2974 if(get_bits1(&s->gb)==0)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2975 return -1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2976
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2977 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2978 if(get_bits1(&s->gb)==0)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2979 return -1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2980 gfid = get_bits(&s->gb, 2); /* GFID */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2981 }else{
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2982 gob_number = get_bits(&s->gb, 5); /* GN */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2983 s->mb_x= 0;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2984 s->mb_y= s->gob_index* gob_number;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2985 gfid = get_bits(&s->gb, 2); /* GFID */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2986 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2987 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2988
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2989 if(s->mb_y >= s->mb_height)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2990 return -1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2991
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2992 if(s->qscale==0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2993 return -1;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
2994
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2995 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2996 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2997
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2998 static inline void memsetw(short *tab, int val, int n)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2999 {
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3000 int i;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3001 for(i=0;i<n;i++)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3002 tab[i] = val;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3003 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3004
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
3005 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
3006
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3007 void ff_mpeg4_init_partitions(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3008 {
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3009 uint8_t *start= pbBufPtr(&s->pb);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3010 uint8_t *end= s->pb.buf_end;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3011 int size= end - start;
2437
8a30df830ad6 x86_64 pointer typecast fix by (Martin Drab <drab kepler.fjfi.cvut cz>)
michael
parents: 2422
diff changeset
3012 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
1912
351e996f29d9 fixing alignment, 2nd try
michael
parents: 1910
diff changeset
3013 int tex_size= (size - 2*pb_size)&(~3);
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3014
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3015 set_put_bits_buffer_size(&s->pb, pb_size);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3016 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
3017 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3018 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3019
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3020 void ff_mpeg4_merge_partitions(MpegEncContext *s)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3021 {
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1773
diff changeset
3022 const int pb2_len = put_bits_count(&s->pb2 );
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1773
diff changeset
3023 const int tex_pb_len= put_bits_count(&s->tex_pb);
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1773
diff changeset
3024 const int bits= put_bits_count(&s->pb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3025
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3026 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3027 put_bits(&s->pb, 19, DC_MARKER);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3028 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3029 s->i_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3030 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3031 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
3032 s->misc_bits+=17 + pb2_len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3033 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3034 s->p_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3035 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3036
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3037 flush_put_bits(&s->pb2);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3038 flush_put_bits(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3039
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3040 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3041 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1796
diff changeset
3042 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
1786
b7340afa261a get_bit_count -> put_bits_count
alex
parents: 1773
diff changeset
3043 s->last_bits= put_bits_count(&s->pb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3044 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3045
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
3046 #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
3047
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3048 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
3049 switch(s->pict_type){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3050 case I_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3051 return 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3052 case P_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3053 case S_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3054 return s->f_code+15;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3055 case B_TYPE:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
3056 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3057 default:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3058 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3059 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3060 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3061
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
3062 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
3063
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3064 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3065 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3066 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3067
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3068 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3069 put_bits(&s->pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3070
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3071 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
3072 put_bits(&s->pb, s->quant_precision, s->qscale);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3073 put_bits(&s->pb, 1, 0); /* no HEC */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3074 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3075
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
3076 #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
3077
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3078 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3079 * 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
3080 * @return 0 if not
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3081 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3082 static inline int mpeg4_is_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3083 const int bits_count= get_bits_count(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3084
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3085 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
3086 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3087 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3088
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
3089 if(bits_count + 8 >= s->gb.size_in_bits){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3090 int v= show_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3091 v|= 0x7F >> (7-(bits_count&7));
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3092
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3093 if(v==0x7F)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3094 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3095 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3096 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3097 int len;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3098 GetBitContext gb= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3099
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3100 skip_bits(&s->gb, 1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3101 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3102
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3103 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3104 if(get_bits1(&s->gb)) break;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3105 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3106
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3107 s->gb= gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3108
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3109 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
3110 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3111 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3112 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3113 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3114 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3115
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3116 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3117 * decodes the next video packet.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3118 * @return <0 if something went wrong
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3119 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3120 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3121 {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3122 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
3123 int header_extension=0, mb_num, len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3124
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3125 /* 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
3126 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
3127
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3128 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3129 if(get_bits1(&s->gb)) break;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3130 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3131
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3132 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
3133 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3134 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3135 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3136
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3137 if(s->shape != RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3138 header_extension= get_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3139 //FIXME more stuff here
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3140 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3141
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3142 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
3143 if(mb_num>=s->mb_num){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3144 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3145 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3146 }
1176
a39d55237445 b frames + slices bugfix
michaelni
parents: 1164
diff changeset
3147 if(s->pict_type == B_TYPE){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3148 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
1176
a39d55237445 b frames + slices bugfix
michaelni
parents: 1164
diff changeset
3149 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
a39d55237445 b frames + slices bugfix
michaelni
parents: 1164
diff changeset
3150 }
a39d55237445 b frames + slices bugfix
michaelni
parents: 1164
diff changeset
3151
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3152 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
3153 s->mb_y= mb_num / s->mb_width;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3154
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3155 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3156 int qscale= get_bits(&s->gb, s->quant_precision);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3157 if(qscale)
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3158 s->chroma_qscale=s->qscale= qscale;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3159 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3160
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3161 if(s->shape == RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3162 header_extension= get_bits1(&s->gb);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3163 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3164 if(header_extension){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3165 int time_increment;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3166 int time_incr=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3167
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3168 while (get_bits1(&s->gb) != 0)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3169 time_incr++;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3170
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3171 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
3172 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
3173 check_marker(&s->gb, "before vop_coding_type in video packed header");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3174
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3175 skip_bits(&s->gb, 2); /* vop coding type */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3176 //FIXME not rect stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3177
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3178 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3179 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3180 //FIXME dont just ignore everything
821
f5f2e162331c hopefully fixing sprite_warping_points==0
michaelni
parents: 815
diff changeset
3181 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
3182 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
3183 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3184 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3185
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3186 //FIXME reduced res stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3187
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3188 if (s->pict_type != I_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3189 int f_code = get_bits(&s->gb, 3); /* fcode_for */
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
3190 if(f_code==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3191 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3192 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3193 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3194 if (s->pict_type == B_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3195 int b_code = get_bits(&s->gb, 3);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
3196 if(b_code==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3197 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
3198 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3199 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3200 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3201 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3202 //FIXME new-pred stuff
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3203
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3204 //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));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3205
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3206 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3207 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3208
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3209 void ff_mpeg4_clean_buffers(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3210 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3211 int c_wrap, c_xy, l_wrap, l_xy;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3212
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
3213 l_wrap= s->b8_stride;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
3214 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
3215 c_wrap= s->mb_stride;
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
3216 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3217
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3218 #if 0
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3219 /* clean DC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3220 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3221 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3222 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
3223 #endif
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3224
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3225 /* clean AC */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3226 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3227 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3228 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3229
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3230 /* clean MV */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3231 // we cant clear the MVs as they might be needed by a b frame
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3232 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3233 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3234 s->last_mv[0][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3235 s->last_mv[0][0][1]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3236 s->last_mv[1][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3237 s->last_mv[1][0][1]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3238 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3239
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3240 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3241 * decodes the group of blocks / video packet header.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3242 * @return <0 if no resync found
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3243 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3244 int ff_h263_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3245 int left, ret;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3246
1521
c232b6753012 h263 GOB decoding fix
michael
parents: 1520
diff changeset
3247 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
3248 skip_bits1(&s->gb);
1521
c232b6753012 h263 GOB decoding fix
michael
parents: 1520
diff changeset
3249 align_get_bits(&s->gb);
c232b6753012 h263 GOB decoding fix
michael
parents: 1520
diff changeset
3250 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3251
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3252 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3253 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3254 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3255 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3256 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3257 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3258 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3259 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3260 //ok, its not where its supposed to be ...
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3261 s->gb= s->last_resync_gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3262 align_get_bits(&s->gb);
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
3263 left= s->gb.size_in_bits - get_bits_count(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3264
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3265 for(;left>16+1+5+5; left-=8){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3266 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3267 GetBitContext bak= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3268
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3269 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3270 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3271 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3272 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3273 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3274 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3275
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3276 s->gb= bak;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3277 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3278 skip_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3279 }
1671
a75cbb4588d1 100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l
michael
parents: 1670
diff changeset
3280
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3281 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3282 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3283
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3284 /**
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3285 * gets the average motion vector for a GMC MB.
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3286 * @param n either 0 for the x component or 1 for y
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3287 * @returns the average MV for a GMC MB
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3288 */
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3289 static inline int get_amv(MpegEncContext *s, int n){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3290 int x, y, mb_v, sum, dx, dy, shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3291 int len = 1 << (s->f_code + 4);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3292 const int a= s->sprite_warping_accuracy;
1997
7bd3932bc918 AMV bug workaround
michael
parents: 1983
diff changeset
3293
7bd3932bc918 AMV bug workaround
michael
parents: 1983
diff changeset
3294 if(s->workaround_bugs & FF_BUG_AMV)
7bd3932bc918 AMV bug workaround
michael
parents: 1983
diff changeset
3295 len >>= s->quarter_sample;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3296
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3297 if(s->real_sprite_warping_points==1){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3298 if(s->divx_version==500 && s->divx_build==413)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3299 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3300 else
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3301 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3302 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3303 dx= s->sprite_delta[n][0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3304 dy= s->sprite_delta[n][1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3305 shift= s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3306 if(n) dy -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3307 else dx -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3308 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3309
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3310 sum=0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3311 for(y=0; y<16; y++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3312 int v;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3313
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3314 v= mb_v + dy*y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3315 //XXX FIXME optimize
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3316 for(x=0; x<16; x++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3317 sum+= v>>shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3318 v+= dx;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3319 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3320 }
999
74dc4105e147 average motion vector rounding like the reference says and not what the standard says
michaelni
parents: 953
diff changeset
3321 sum= RSHIFT(sum, a+8-s->quarter_sample);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3322 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3323
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3324 if (sum < -len) sum= -len;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3325 else if (sum >= len) sum= len-1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3326
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3327 return sum;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3328 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3329
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3330 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3331 * decodes first partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3332 * @return number of MBs decoded or <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3333 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3334 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
3335 int mb_num;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3336 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3337
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3338 /* decode first partition */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3339 mb_num=0;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3340 s->first_slice_line=1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3341 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
3342 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3343 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
3344 const int xy= s->mb_x + s->mb_y*s->mb_stride;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3345 int cbpc;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3346 int dir=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3347
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3348 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3349 ff_update_block_index(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3350 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3351 s->first_slice_line=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3352
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3353 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3354 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3355
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3356 do{
1873
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3357 if(show_bits_long(&s->gb, 19)==DC_MARKER){
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3358 return mb_num-1;
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3359 }
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3360
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3361 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3362 if (cbpc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3363 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3364 return -1;
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3365 }
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3366 }while(cbpc == 8);
1873
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3367
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3368 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
3369 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3370 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3371
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3372 if(cbpc & 4) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
3373 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3374 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3375 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3376
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3377 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3378 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3379 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3380 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3381 if(dc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3382 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
3383 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3384 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3385 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3386 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3387 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3388 s->pred_dir_table[xy]= dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3389 }else{ /* P/S_TYPE */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3390 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
3391 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
3392 const int stride= s->b8_stride*2;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3393
1873
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3394 try_again:
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3395 bits= show_bits(&s->gb, 17);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3396 if(bits==MOTION_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3397 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3398 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3399 skip_bits1(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3400 if(bits&0x10000){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3401 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3402 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3403 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3404 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3405 my= get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3406 }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
3407 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3408 mx=my=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3409 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3410 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3411 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3412 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3413 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3414
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3415 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3416 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3417 continue;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3418 }
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3419
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3420 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3421 if (cbpc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3422 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3423 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3424 }
1873
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3425 if(cbpc == 20)
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3426 goto try_again;
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3427
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3428 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3429
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3430 s->mb_intra = ((cbpc & 4) != 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3431
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3432 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
3433 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3434 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3435 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3436 mot_val[0+stride]= mot_val[2+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3437 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3438 mot_val[1+stride]= mot_val[3+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3439 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3440 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3441 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3442
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3443 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3444 s->mcsel= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3445 else s->mcsel= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3446
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3447 if ((cbpc & 16) == 0) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3448 /* 16x16 motion prediction */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3449
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
3450 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3451 if(!s->mcsel){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3452 mx = h263_decode_motion(s, pred_x, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3453 if (mx >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3454 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3455
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3456 my = h263_decode_motion(s, pred_y, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3457 if (my >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3458 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
3459 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3460 } else {
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3461 mx = get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3462 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
3463 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3464 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3465
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3466 mot_val[0 ]= mot_val[2 ] =
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3467 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3468 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3469 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3470 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3471 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
3472 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3473 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
3474 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3475 mx = h263_decode_motion(s, pred_x, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3476 if (mx >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3477 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3478
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3479 my = h263_decode_motion(s, pred_y, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3480 if (my >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3481 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3482 mot_val[0] = mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3483 mot_val[1] = my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3484 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3485 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3486 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3487 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3488 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3489 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3490 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3491
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3492 return mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3493 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3494
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3495 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3496 * decode second partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3497 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3498 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3499 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
3500 int mb_num=0;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3501 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
3502
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3503 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
3504 s->first_slice_line=1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3505 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
3506 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3507 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
3508 const int xy= s->mb_x + s->mb_y*s->mb_stride;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3509
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3510 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3511 ff_update_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3512 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
3513 s->first_slice_line=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3514
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3515 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3516 int ac_pred= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3517 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3518 if(cbpy<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3519 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
3520 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3521 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3522
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3523 s->cbp_table[xy]|= cbpy<<2;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3524 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3525 }else{ /* P || S_TYPE */
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3526 if(IS_INTRA(s->current_picture.mb_type[xy])){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3527 int dir=0,i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3528 int ac_pred = get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3529 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3530
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3531 if(cbpy<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3532 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
3533 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3534 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3535
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3536 if(s->cbp_table[xy] & 8) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
3537 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3538 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3539 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3540
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3541 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3542 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3543 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3544 if(dc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3545 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
3546 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3547 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3548 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3549 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3550 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3551 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3552 s->cbp_table[xy]|= cbpy<<2;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3553 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3554 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
3555 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3556 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3557 s->cbp_table[xy]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3558 }else{
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3559 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3560
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3561 if(cbpy<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3562 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
3563 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3564 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3565
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3566 if(s->cbp_table[xy] & 8) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
3567 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3568 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3569 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3570
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3571 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3572 s->cbp_table[xy]|= (cbpy^0xf)<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3573 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3574 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3575 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3576 if(mb_num >= mb_count) return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3577 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3578 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3579 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3580 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3581
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3582 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3583 * decodes the first & second partition
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3584 * @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
3585 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3586 int ff_mpeg4_decode_partitions(MpegEncContext *s)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3587 {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3588 int mb_num;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3589 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3590 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3591
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3592 mb_num= mpeg4_decode_partition_a(s);
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3593 if(mb_num<0){
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3594 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
3595 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3596 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3597
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3598 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
3599 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3600 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
3601 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3602 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3603
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3604 s->mb_num_left= mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3605
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3606 if(s->pict_type==I_TYPE){
1873
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3607 while(show_bits(&s->gb, 9) == 1)
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3608 skip_bits(&s->gb, 9);
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1255
diff changeset
3609 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
3610 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
3611 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3612 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3613 }else{
1873
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3614 while(show_bits(&s->gb, 10) == 1)
c26242faa246 mb stuffing in partitioned frames fix
michael
parents: 1872
diff changeset
3615 skip_bits(&s->gb, 10);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3616 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
3617 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
3618 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3619 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3620 }
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3621 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3622
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3623 if( mpeg4_decode_partition_b(s, mb_num) < 0){
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3624 if(s->pict_type==P_TYPE)
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3625 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
3626 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3627 }else{
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3628 if(s->pict_type==P_TYPE)
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3629 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
3630 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3631
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3632 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3633 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3634
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3635 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3636 * decode partition C of one MB.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3637 * @return <0 if an error occured
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 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3640 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3641 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
3642 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
3643
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3644 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
3645 cbp = s->cbp_table[xy];
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3646
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3647 if(s->current_picture.qscale_table[xy] != s->qscale){
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
3648 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3649 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3650
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3651 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3652 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3653 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
3654 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
3655 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3656 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3657 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
3658
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3659 if (IS_SKIP(mb_type)) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3660 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3661 for(i=0;i<6;i++)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3662 s->block_last_index[i] = -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3663 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3664 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3665 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3666 s->mcsel=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3667 s->mb_skiped = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3668 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3669 s->mcsel=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3670 s->mb_skiped = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3671 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3672 }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
3673 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3674 }else if(!s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3675 // s->mcsel= 0; //FIXME do we need to init that
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3676
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3677 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
3678 if (IS_8X8(mb_type)) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3679 s->mv_type = MV_TYPE_8X8;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3680 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3681 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3682 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3683 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3684 } else { /* I-Frame */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3685 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
3686 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3687 }
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3688
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3689 if (!IS_SKIP(mb_type)) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3690 int i;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3691 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3692 for (i = 0; i < 6; i++) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3693 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
3694 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3695 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3696 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3697 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3698 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3699 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3700
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3701 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3702
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3703 if(--s->mb_num_left <= 0){
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
3704 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3705 if(mpeg4_is_resync(s))
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3706 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3707 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3708 return SLICE_NOEND;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3709 }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
3710 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
3711 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
3712 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
3713 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
3714 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead 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 return SLICE_OK;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3716 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3717 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3718
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3719 /**
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3720 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3721 */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3722 static void preview_obmc(MpegEncContext *s){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3723 GetBitContext gb= s->gb;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3724
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3725 int cbpc, i, pred_x, pred_y, mx, my;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3726 int16_t *mot_val;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3727 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
3728 const int stride= s->b8_stride*2;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3729
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3730 for(i=0; i<4; i++)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3731 s->block_index[i]+= 2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3732 for(i=4; i<6; i++)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3733 s->block_index[i]+= 1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3734 s->mb_x++;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3735
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3736 assert(s->pict_type == P_TYPE);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3737
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3738 do{
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3739 if (get_bits1(&s->gb)) {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3740 /* 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
3741 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3742 mot_val[0 ]= mot_val[2 ]=
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3743 mot_val[0+stride]= mot_val[2+stride]= 0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3744 mot_val[1 ]= mot_val[3 ]=
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3745 mot_val[1+stride]= mot_val[3+stride]= 0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3746
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3747 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3748 goto end;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3749 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3750 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3751 }while(cbpc == 20);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3752
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3753 if(cbpc & 4){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3754 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3755 }else{
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3756 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3757 if (cbpc & 8) {
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3758 if(s->modified_quant){
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3759 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3760 else skip_bits(&s->gb, 5);
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3761 }else
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3762 skip_bits(&s->gb, 2);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3763 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3764
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3765 if ((cbpc & 16) == 0) {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3766 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3767 /* 16x16 motion prediction */
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
3768 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3769 if (s->umvplus)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3770 mx = h263p_decode_umotion(s, pred_x);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3771 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3772 mx = h263_decode_motion(s, pred_x, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3773
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3774 if (s->umvplus)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3775 my = h263p_decode_umotion(s, pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3776 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3777 my = h263_decode_motion(s, pred_y, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3778
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3779 mot_val[0 ]= mot_val[2 ]=
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3780 mot_val[0+stride]= mot_val[2+stride]= mx;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3781 mot_val[1 ]= mot_val[3 ]=
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3782 mot_val[1+stride]= mot_val[3+stride]= my;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3783 } else {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3784 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3785 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
3786 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3787 if (s->umvplus)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3788 mx = h263p_decode_umotion(s, pred_x);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3789 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3790 mx = h263_decode_motion(s, pred_x, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3791
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3792 if (s->umvplus)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3793 my = h263p_decode_umotion(s, pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3794 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3795 my = h263_decode_motion(s, pred_y, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3796 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3797 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3798 mot_val[0] = mx;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3799 mot_val[1] = my;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3800 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3801 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3802 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3803 end:
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3804
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3805 for(i=0; i<4; i++)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3806 s->block_index[i]-= 2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3807 for(i=4; i<6; i++)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3808 s->block_index[i]-= 1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3809 s->mb_x--;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3810
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3811 s->gb= gb;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3812 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3813
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3814 static void h263_decode_dquant(MpegEncContext *s){
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3815 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3816
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3817 if(s->modified_quant){
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3818 if(get_bits1(&s->gb))
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3819 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3820 else
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3821 s->qscale= get_bits(&s->gb, 5);
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3822 }else
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3823 s->qscale += quant_tab[get_bits(&s->gb, 2)];
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3824 ff_set_qscale(s, s->qscale);
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3825 }
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3826
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3827 int ff_h263_decode_mb(MpegEncContext *s,
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3828 DCTELEM block[6][64])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3829 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3830 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3831 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
3832 const int xy= s->mb_x + s->mb_y * s->mb_stride;
1521
c232b6753012 h263 GOB decoding fix
michael
parents: 1520
diff changeset
3833
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3834 assert(!s->h263_pred);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3835
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3836 if (s->pict_type == P_TYPE) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3837 do{
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3838 if (get_bits1(&s->gb)) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3839 /* skip mb */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3840 s->mb_intra = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3841 for(i=0;i<6;i++)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3842 s->block_last_index[i] = -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3843 s->mv_dir = MV_DIR_FORWARD;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3844 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
3845 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3846 s->mv[0][0][0] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3847 s->mv[0][0][1] = 0;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3848 s->mb_skiped = !(s->obmc | s->loop_filter);
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3849 goto end;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3850 }
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3851 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
3852 //fprintf(stderr, "\tCBPC: %d", cbpc);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3853 if (cbpc < 0){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3854 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
3855 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3856 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3857 }while(cbpc == 20);
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
3858
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3859 dquant = cbpc & 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3860 s->mb_intra = ((cbpc & 4) != 0);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3861 if (s->mb_intra) goto intra;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3862
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3863 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3864
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3865 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3866 cbpy ^= 0xF;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3867
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3868 cbp = (cbpc & 3) | (cbpy << 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3869 if (dquant) {
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3870 h263_decode_dquant(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3871 }
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3872
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3873 s->mv_dir = MV_DIR_FORWARD;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3874 if ((cbpc & 16) == 0) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3875 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3876 /* 16x16 motion prediction */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3877 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
3878 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
3879 if (s->umvplus)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3880 mx = h263p_decode_umotion(s, pred_x);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3881 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3882 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
3883
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3884 if (mx >= 0xffff)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3885 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3886
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3887 if (s->umvplus)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3888 my = h263p_decode_umotion(s, pred_y);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3889 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3890 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
3891
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3892 if (my >= 0xffff)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3893 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3894 s->mv[0][0][0] = mx;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3895 s->mv[0][0][1] = my;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3896
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3897 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
3898 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
3899 } else {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3900 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3901 s->mv_type = MV_TYPE_8X8;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3902 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
3903 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
3904 if (s->umvplus)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3905 mx = h263p_decode_umotion(s, pred_x);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3906 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3907 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
3908 if (mx >= 0xffff)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3909 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3910
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3911 if (s->umvplus)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3912 my = h263p_decode_umotion(s, pred_y);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3913 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3914 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
3915 if (my >= 0xffff)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3916 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3917 s->mv[0][i][0] = mx;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3918 s->mv[0][i][1] = my;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3919 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
3920 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
3921 mot_val[0] = mx;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3922 mot_val[1] = my;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3923 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3924 }
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3925
1796
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
3926 /* decode each block */
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
3927 for (i = 0; i < 6; i++) {
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
3928 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
3929 return -1;
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
3930 cbp+=cbp;
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
3931 }
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
3932
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3933 if(s->obmc){
1796
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
3934 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3935 preview_obmc(s);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3936 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3937 } else if(s->pict_type==B_TYPE) {
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3938 int mb_type;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3939 const int stride= s->b8_stride;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3940 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3941 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3942 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3943
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3944 //FIXME ugly
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3945 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3946 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3947 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3948 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3949
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3950 do{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3951 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3952 if (mb_type < 0){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3953 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3954 return -1;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3955 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3956
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3957 mb_type= h263_mb_type_b_map[ mb_type ];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3958 }while(!mb_type);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3959
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3960 s->mb_intra = IS_INTRA(mb_type);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3961 if(HAS_CBP(mb_type)){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3962 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3963 if(s->mb_intra){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3964 dquant = IS_QUANT(mb_type);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3965 goto intra;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3966 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3967
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3968 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3969
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3970 if (cbpy < 0){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3971 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3972 return -1;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3973 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3974
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3975 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3976 cbpy ^= 0xF;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3977
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3978 cbp = (cbpc & 3) | (cbpy << 2);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3979 }else
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3980 cbp=0;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3981
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3982 assert(!s->mb_intra);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3983
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3984 if(IS_QUANT(mb_type)){
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3985 h263_decode_dquant(s);
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3986 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3987
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3988 if(IS_DIRECT(mb_type)){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3989 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3990 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3991 }else{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3992 s->mv_dir = 0;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3993 s->mv_type= MV_TYPE_16X16;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3994 //FIXME UMV
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3995
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3996 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
3997 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3998 s->mv_dir = MV_DIR_FORWARD;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3999
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4000 mx = h263_decode_motion(s, mx, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4001 my = h263_decode_motion(s, my, 1);
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
4002
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4003 s->mv[0][0][0] = mx;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4004 s->mv[0][0][1] = my;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
4005 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
4006 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4007 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4008
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4009 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
4010 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4011 s->mv_dir |= MV_DIR_BACKWARD;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
4012
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4013 mx = h263_decode_motion(s, mx, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4014 my = h263_decode_motion(s, my, 1);
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
4015
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4016 s->mv[1][0][0] = mx;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4017 s->mv[1][0][1] = my;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
4018 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
4019 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4020 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4021 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4022
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4023 s->current_picture.mb_type[xy]= mb_type;
1796
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4024
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4025 /* decode each block */
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4026 for (i = 0; i < 6; i++) {
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4027 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4028 return -1;
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4029 cbp+=cbp;
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4030 }
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4031 } else { /* I-Frame */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4032 do{
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4033 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
4034 if (cbpc < 0){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4035 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
4036 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4037 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4038 }while(cbpc == 8);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4039
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4040 dquant = cbpc & 4;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4041 s->mb_intra = 1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4042 intra:
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4043 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
4044 if (s->h263_aic) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4045 s->ac_pred = get_bits1(&s->gb);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4046 if(s->ac_pred){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4047 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
4048
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4049 s->h263_aic_dir = get_bits1(&s->gb);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4050 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4051 }else
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4052 s->ac_pred = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4053
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4054 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
4055 if(cbpy<0){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4056 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
4057 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4058 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4059 cbp = (cbpc & 3) | (cbpy << 2);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4060 if (dquant) {
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
4061 h263_decode_dquant(s);
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4062 }
1796
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4063
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4064 /* decode each block */
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4065 for (i = 0; i < 6; i++) {
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4066 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4067 return -1;
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4068 cbp+=cbp;
7186712b391e rv10/obmc fixes
michael
parents: 1795
diff changeset
4069 }
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4070 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4071 end:
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4072
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4073 /* per-MB end of slice check */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4074 {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4075 int v= show_bits(&s->gb, 16);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4076
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4077 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
4078 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
4079 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4080
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4081 if(v==0)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4082 return SLICE_END;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4083 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4084
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4085 return SLICE_OK;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4086 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4087
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4088 int ff_mpeg4_decode_mb(MpegEncContext *s,
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4089 DCTELEM block[6][64])
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4090 {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4091 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
4092 int16_t *mot_val;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4093 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
4094 const int xy= s->mb_x + s->mb_y * s->mb_stride;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4095
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4096 assert(s->h263_pred);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4097
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4098 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4099 do{
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4100 if (get_bits1(&s->gb)) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4101 /* skip mb */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4102 s->mb_intra = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4103 for(i=0;i<6;i++)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4104 s->block_last_index[i] = -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4105 s->mv_dir = MV_DIR_FORWARD;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4106 s->mv_type = MV_TYPE_16X16;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4107 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4108 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
4109 s->mcsel=1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4110 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
4111 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
4112
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4113 s->mb_skiped = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4114 }else{
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4115 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
4116 s->mcsel=0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4117 s->mv[0][0][0] = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4118 s->mv[0][0][1] = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4119 s->mb_skiped = 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 goto end;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4122 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4123 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
4124 //fprintf(stderr, "\tCBPC: %d", cbpc);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4125 if (cbpc < 0){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4126 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
4127 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4128 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4129 }while(cbpc == 20);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4130
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4131 dquant = cbpc & 8;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4132 s->mb_intra = ((cbpc & 4) != 0);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4133 if (s->mb_intra) goto intra;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4134
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4135 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4136 s->mcsel= get_bits1(&s->gb);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4137 else s->mcsel= 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4138 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4139
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4140 cbp = (cbpc & 3) | (cbpy << 2);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4141 if (dquant) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
4142 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
4143 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4144 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
4145 s->interlaced_dct= get_bits1(&s->gb);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4146
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4147 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4148 if ((cbpc & 16) == 0) {
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4149 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
4150 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
4151 /* 16x16 global motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4152 s->mv_type = MV_TYPE_16X16;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4153 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4154 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
4155 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
4156 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
4157 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4158 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
4159 /* 16x8 field motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4160 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
4161
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4162 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
4163 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
4164
1938
e2501e6e7ff7 unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents: 1936
diff changeset
4165 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4166
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4167 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
4168 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
4169 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4170 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4171
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4172 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
4173 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4174 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4175
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4176 s->mv[0][i][0] = mx;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4177 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
4178 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4179 }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
4180 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
4181 /* 16x16 motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4182 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
4183 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
4184 mx = h263_decode_motion(s, pred_x, s->f_code);
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4185
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4186 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4187 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4188
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4189 my = h263_decode_motion(s, pred_y, s->f_code);
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4190
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4191 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4192 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4193 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
4194 s->mv[0][0][1] = my;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4195 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4196 } 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
4197 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4198 s->mv_type = MV_TYPE_8X8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4199 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
4200 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
4201 mx = h263_decode_motion(s, pred_x, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4202 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4203 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4204
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4205 my = h263_decode_motion(s, pred_y, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4206 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4207 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4208 s->mv[0][i][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4209 s->mv[0][i][1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4210 mot_val[0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4211 mot_val[1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4212 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4213 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4214 } else if(s->pict_type==B_TYPE) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4215 int modb1; // first bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4216 int modb2; // second bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4217 int mb_type;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4218
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4219 s->mb_intra = 0; //B-frames never contain intra blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4220 s->mcsel=0; // ... true gmc blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4221
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4222 if(s->mb_x==0){
674
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4223 for(i=0; i<2; i++){
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4224 s->last_mv[i][0][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4225 s->last_mv[i][0][1]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4226 s->last_mv[i][1][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4227 s->last_mv[i][1][1]= 0;
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4228 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4229 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4230
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4231 /* if we skipped it in the future P Frame than skip it now too */
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4232 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4233
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4234 if(s->mb_skiped){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4235 /* skip mb */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4236 for(i=0;i<6;i++)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4237 s->block_last_index[i] = -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4238
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4239 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4240 s->mv_type = MV_TYPE_16X16;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4241 s->mv[0][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4242 s->mv[0][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4243 s->mv[1][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4244 s->mv[1][0][1] = 0;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4245 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
4246 goto end;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4247 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4248
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4249 modb1= get_bits1(&s->gb);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4250 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
4251 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4252 cbp=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4253 }else{
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4254 modb2= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4255 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
4256 if(mb_type<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4257 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
4258 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
4259 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4260 mb_type= mb_type_b_map[ mb_type ];
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4261 if(modb2) cbp= 0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4262 else cbp= get_bits(&s->gb, 6);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4263
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4264 if ((!IS_DIRECT(mb_type)) && cbp) {
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4265 if(get_bits1(&s->gb)){
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
4266 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4267 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4268 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4269
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4270 if(!s->progressive_sequence){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4271 if(cbp)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4272 s->interlaced_dct= get_bits1(&s->gb);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4273
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4274 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
4275 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
4276 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
4277
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4278 if(USES_LIST(mb_type, 0)){
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4279 s->field_select[0][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4280 s->field_select[0][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4281 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4282 if(USES_LIST(mb_type, 1)){
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4283 s->field_select[1][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4284 s->field_select[1][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4285 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4286 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4287 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4288
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4289 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
4290 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4291 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
4292
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4293 if(USES_LIST(mb_type, 0)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4294 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4295
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4296 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4297 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4298 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4299 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4300 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4301
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4302 if(USES_LIST(mb_type, 1)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4303 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4304
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4305 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4306 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4307 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4308 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4309 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4310 }else if(!IS_DIRECT(mb_type)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4311 s->mv_type= MV_TYPE_FIELD;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4312
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4313 if(USES_LIST(mb_type, 0)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4314 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4315
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4316 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4317 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4318 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4319 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4320 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4321 }
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4322 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4323
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4324 if(USES_LIST(mb_type, 1)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4325 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4326
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4327 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4328 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4329 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4330 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4331 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4332 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4333 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4334 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4335 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4336
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4337 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
4338 if(IS_SKIP(mb_type))
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4339 mx=my=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4340 else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4341 mx = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4342 my = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4343 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4344
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4345 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
4346 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4347 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4348 s->current_picture.mb_type[xy]= mb_type;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4349 } else { /* I-Frame */
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4350 do{
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4351 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4352 if (cbpc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4353 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4354 return -1;
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4355 }
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4356 }while(cbpc == 8);
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4357
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4358 dquant = cbpc & 4;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4359 s->mb_intra = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4360 intra:
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4361 s->ac_pred = get_bits1(&s->gb);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4362 if(s->ac_pred)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4363 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
4364 else
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4365 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4366
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4367 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4368 if(cbpy<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4369 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4370 return -1;
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4371 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4372 cbp = (cbpc & 3) | (cbpy << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4373 if (dquant) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
4374 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4375 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4376
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4377 if(!s->progressive_sequence)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4378 s->interlaced_dct= get_bits1(&s->gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4379
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4380 /* decode each block */
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4381 for (i = 0; i < 6; i++) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4382 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
4383 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4384 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4385 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4386 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4387 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4388
986e461dc072 Initial revision
glantau
parents:
diff changeset
4389 /* decode each block */
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4390 for (i = 0; i < 6; i++) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4391 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
4392 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4393 cbp+=cbp;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4394 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4395 end:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4396
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4397 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4398 if(s->codec_id==CODEC_ID_MPEG4){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4399 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
4400 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
4401 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4402 return SLICE_OK;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4403 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4404 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4405 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4406
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4407 return SLICE_OK;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4408 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4409
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4410 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4411 {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
4412 int code, val, sign, shift, l;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4413 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4414
986e461dc072 Initial revision
glantau
parents:
diff changeset
4415 if (code == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4416 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
4417 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
4418 return 0xffff;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4419
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4420 sign = get_bits1(&s->gb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4421 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
4422 val = code;
625ccacd1113 decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1254
diff changeset
4423 if (shift) {
625ccacd1113 decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1254
diff changeset
4424 val = (val - 1) << shift;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4425 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
4426 val++;
625ccacd1113 decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1254
diff changeset
4427 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4428 if (sign)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4429 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4430 val += pred;
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
4431
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4432 /* modulo decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4433 if (!s->h263_long_vectors) {
2093
82816cad0e29 optimization
michael
parents: 2080
diff changeset
4434 l = INT_BIT - 5 - f_code;
82816cad0e29 optimization
michael
parents: 2080
diff changeset
4435 val = (val<<l)>>l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4436 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4437 /* horrible h263 long vector mode */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4438 if (pred < -31 && val < -63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4439 val += 64;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4440 if (pred > 32 && val > 63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4441 val -= 64;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
4442
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4443 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4444 return val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4445 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4446
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4447 /* Decodes RVLC of H.263+ UMV */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4448 static int h263p_decode_umotion(MpegEncContext * s, int pred)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4449 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4450 int code = 0, sign;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4451
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4452 if (get_bits1(&s->gb)) /* Motion difference = 0 */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4453 return pred;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4454
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4455 code = 2 + get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4456
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4457 while (get_bits1(&s->gb))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4458 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4459 code <<= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4460 code += get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4461 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4462 sign = code & 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4463 code >>= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4464
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4465 code = (sign) ? (pred - code) : (pred + code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4466 #ifdef DEBUG
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4467 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4468 #endif
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4469 return code;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4470
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4471 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4472
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4473 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4474 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4475 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4476 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4477 RLTable *rl = &rl_inter;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
4478 const uint8_t *scan_table;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4479 GetBitContext gb= s->gb;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4480
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4481 scan_table = s->intra_scantable.permutated;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4482 if (s->h263_aic && s->mb_intra) {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4483 rl = &rl_intra_aic;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4484 i = 0;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4485 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4486 if (s->h263_aic_dir)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4487 scan_table = s->intra_v_scantable.permutated; /* left */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4488 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4489 scan_table = s->intra_h_scantable.permutated; /* top */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4490 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4491 } else if (s->mb_intra) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4492 /* DC coef */
1641
0226cad80fc2 cleanup
michael
parents: 1639
diff changeset
4493 if(s->codec_id == CODEC_ID_RV10){
1090
michaelni
parents: 1089
diff changeset
4494 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4495 int component, diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4496 component = (n <= 3 ? 0 : n - 4 + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4497 level = s->last_dc[component];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4498 if (s->rv10_first_dc_coded[component]) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4499 diff = rv_decode_dc(s, n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4500 if (diff == 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4501 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4502 level += diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4503 level = level & 0xff; /* handle wrap round */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4504 s->last_dc[component] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4505 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4506 s->rv10_first_dc_coded[component] = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4507 }
1090
michaelni
parents: 1089
diff changeset
4508 } else {
michaelni
parents: 1089
diff changeset
4509 level = get_bits(&s->gb, 8);
1975
6876ae55b5e7 rv10 decoding fix
michael
parents: 1948
diff changeset
4510 if (level == 255)
6876ae55b5e7 rv10 decoding fix
michael
parents: 1948
diff changeset
4511 level = 128;
1090
michaelni
parents: 1089
diff changeset
4512 }
michaelni
parents: 1089
diff changeset
4513 }else{
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4514 level = get_bits(&s->gb, 8);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4515 if((level&0x7F) == 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4516 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
1752
9f47c2211da9 more tolerance for dc=0
michael
parents: 1739
diff changeset
4517 if(s->error_resilience >= FF_ER_COMPLIANT)
9f47c2211da9 more tolerance for dc=0
michael
parents: 1739
diff changeset
4518 return -1;
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4519 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4520 if (level == 255)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4521 level = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4522 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4523 block[0] = level;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4524 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4525 } else {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4526 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4527 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4528 if (!coded) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4529 if (s->mb_intra && s->h263_aic)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4530 goto not_coded;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4531 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4532 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4533 }
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4534 retry:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4535 for(;;) {
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4536 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
4537 if (code < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4538 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4539 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4540 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4541 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4542 /* escape */
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4543 if (s->h263_flv > 1) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4544 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
4545 last = get_bits1(&s->gb);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4546 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
4547 if(is11){
1356
9e31b6bfb1a2 fix? flv escape codes
michaelni
parents: 1354
diff changeset
4548 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
4549 } else {
1356
9e31b6bfb1a2 fix? flv escape codes
michaelni
parents: 1354
diff changeset
4550 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
4551 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4552 } else {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4553 last = get_bits1(&s->gb);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4554 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
4555 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
4556 if(level == -128){
1641
0226cad80fc2 cleanup
michael
parents: 1639
diff changeset
4557 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
4558 /* XXX: should patch encoder too */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4559 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
4560 }else{
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4561 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
4562 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
4563 }
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4564 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4565 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4566 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4567 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4568 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4569 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4570 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4571 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4572 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4573 i += run;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4574 if (i >= 64){
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4575 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4576 //looks like a hack but no, its the way its supposed to work ...
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4577 rl = &rl_intra_aic;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4578 i = 0;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4579 s->gb= gb;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4580 memset(block, 0, sizeof(DCTELEM)*64);
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4581 goto retry;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4582 }
2406
25a24139f296 WV1F support
michael
parents: 2370
diff changeset
4583 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
986e461dc072 Initial revision
glantau
parents:
diff changeset
4584 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4585 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4586 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4587 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4588 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4589 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4590 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4591 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4592 not_coded:
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4593 if (s->mb_intra && s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4594 h263_pred_acdc(s, block, n);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
4595 i = 63;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4596 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4597 s->block_last_index[n] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4598 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4599 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4600
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4601 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4602 * decodes the dc value.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4603 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4604 * @param dir_ptr the prediction direction will be stored here
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4605 * @return the quantized dc
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4606 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4607 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4608 {
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
4609 int level, code;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4610
986e461dc072 Initial revision
glantau
parents:
diff changeset
4611 if (n < 4)
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4612 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4613 else
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4614 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4615 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
4616 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4617 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4618 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4619 if (code == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4620 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4621 } 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
4622 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
4623 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
4624 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
4625 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
4626 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
4627 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
4628 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
4629 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
4630 }
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
4631 }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
4632 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
4633 }
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
4634
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4635 if (code > 8){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4636 if(get_bits1(&s->gb)==0){ /* marker */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4637 if(s->error_resilience>=2){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4638 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
4639 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4640 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4641 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4642 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4643 }
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
4644
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
4645 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4646 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4647
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4648 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4649 * decodes a block.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4650 * @return <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4651 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4652 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4653 int n, int coded, int intra, int rvlc)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4654 {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4655 int level, i, last, run;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4656 int dc_pred_dir;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4657 RLTable * rl;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4658 RL_VLC_ELEM * rl_vlc;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
4659 const uint8_t * scan_table;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4660 int qmul, qadd;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4661
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4662 //Note intra & rvlc should be optimized away if this is inlined
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4663
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4664 if(intra) {
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4665 if(s->qscale < s->intra_dc_threshold){
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4666 /* DC coef */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4667 if(s->partitioned_frame){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4668 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
4669 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
4670 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
4671 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4672 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4673 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4674 if (level < 0)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4675 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4676 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4677 block[0] = level;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4678 i = 0;
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4679 }else{
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4680 i = -1;
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4681 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4682 if (!coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4683 goto not_coded;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4684
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4685 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4686 rl = &rvlc_rl_intra;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4687 rl_vlc = rvlc_rl_intra.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4688 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4689 rl = &rl_intra;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4690 rl_vlc = rl_intra.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4691 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4692 if (s->ac_pred) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4693 if (dc_pred_dir == 0)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4694 scan_table = s->intra_v_scantable.permutated; /* left */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4695 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4696 scan_table = s->intra_h_scantable.permutated; /* top */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4697 } else {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4698 scan_table = s->intra_scantable.permutated;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4699 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4700 qmul=1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4701 qadd=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4702 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4703 i = -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4704 if (!coded) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4705 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4706 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4707 }
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4708 if(rvlc) rl = &rvlc_rl_inter;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4709 else rl = &rl_inter;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4710
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4711 scan_table = s->intra_scantable.permutated;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4712
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4713 if(s->mpeg_quant){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4714 qmul=1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4715 qadd=0;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4716 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4717 rl_vlc = rvlc_rl_inter.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4718 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4719 rl_vlc = rl_inter.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4720 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4721 }else{
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4722 qmul = s->qscale << 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4723 qadd = (s->qscale - 1) | 1;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4724 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4725 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4726 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4727 rl_vlc = rl_inter.rl_vlc[s->qscale];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4728 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4729 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4730 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4731 {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4732 OPEN_READER(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4733 for(;;) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4734 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4735 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4736 if (level==0) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4737 /* escape */
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4738 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4739 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
4740 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4741 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4742 }; SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4743
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4744 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4745 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4746 SKIP_COUNTER(re, &s->gb, 1+1+6);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4747 UPDATE_CACHE(re, &s->gb);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4748
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4749 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
4750 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4751 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4752 }; SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4753
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4754 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4755
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4756 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
4757 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4758 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4759 }; SKIP_CACHE(re, &s->gb, 5);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4760
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4761 level= level * qmul + qadd;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4762 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4763 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4764
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4765 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
4766 if(last) i+=192;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4767 }else{
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4768 int cache;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4769 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
4770
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
4771 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
4772 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
4773
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4774 if (cache&0x80000000) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4775 if (cache&0x40000000) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4776 /* third escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4777 SKIP_CACHE(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4778 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4779 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4780 SKIP_COUNTER(re, &s->gb, 2+1+6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4781 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4782
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
4783 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
4784 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
4785 }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
4786 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
4787 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
4788 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
4789 }; 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
4790
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
4791 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
4792
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
4793 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
4794 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
4795 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
4796 }; 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
4797
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
4798 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
4799 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4800
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
4801 #if 0
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
4802 if(s->error_resilience >= FF_ER_COMPLIANT){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4803 const int abs_level= ABS(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
4804 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4805 const int run1= run - rl->max_run[last][abs_level] - 1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4806 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
4807 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
4808 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4809 }
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
4810 if(s->error_resilience > FF_ER_COMPLIANT){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4811 if(abs_level <= rl->max_level[last][run]*2){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4812 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4813 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
4814 }
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
4815 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4816 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4817 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
4818 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4819 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4820 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4821 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4822 #endif
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4823 if (level>0) level= level * qmul + qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4824 else level= level * qmul - qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4825
2080
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4826 if((unsigned)(level + 2048) > 4095){
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4827 if(s->error_resilience > FF_ER_COMPLIANT){
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4828 if(level > 2560 || level<-2560){
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4829 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4830 return -1;
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4831 }
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4832 }
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4833 level= level<0 ? -2048 : 2047;
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4834 }
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
4835
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4836 i+= run + 1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4837 if(last) i+=192;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4838 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4839 /* second escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4840 #if MIN_CACHE_BITS < 20
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4841 LAST_SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4842 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4843 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4844 SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4845 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4846 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4847 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4848 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4849 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4850 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4851 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4852 /* first escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4853 #if MIN_CACHE_BITS < 19
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4854 LAST_SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4855 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4856 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4857 SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4858 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4859 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4860 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4861 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4862 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4863 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4864 }
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4865 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4866 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4867 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4868 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4869 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4870 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4871 if (i > 62){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4872 i-= 192;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4873 if(i&(~63)){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4874 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
4875 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4876 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4877
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4878 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4879 break;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4880 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4881
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4882 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4883 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4884 CLOSE_READER(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4885 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4886 not_coded:
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4887 if (intra) {
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4888 if(s->qscale >= s->intra_dc_threshold){
2003
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
4889 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
16ac9630317d mpeg4 dc prediction simplification
michael
parents: 1997
diff changeset
4890
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4891 if(i == -1) i=0;
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4892 }
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4893
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4894 mpeg4_pred_ac(s, block, n, dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4895 if (s->ac_pred) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4896 i = 63; /* XXX: not optimal */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4897 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4898 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4899 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4900 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4901 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4902
986e461dc072 Initial revision
glantau
parents:
diff changeset
4903 /* most is hardcoded. should extend to handle all h263 streams */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4904 int h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4905 {
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4906 int format, width, height, i;
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4907 uint32_t startcode;
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4908
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4909 align_get_bits(&s->gb);
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4910
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4911 startcode= get_bits(&s->gb, 22-8);
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4912
1393
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1390
diff changeset
4913 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4914 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4915
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4916 if(startcode == 0x20)
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4917 break;
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4918 }
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4919
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4920 if (startcode != 0x20) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4921 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4922 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4923 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4924 /* temporal reference */
1865
92e94c550def h263 framerate & aspect ratio fixes
michael
parents: 1831
diff changeset
4925 i = get_bits(&s->gb, 8); /* picture timestamp */
92e94c550def h263 framerate & aspect ratio fixes
michael
parents: 1831
diff changeset
4926 if( (s->picture_number&~0xFF)+i < s->picture_number)
92e94c550def h263 framerate & aspect ratio fixes
michael
parents: 1831
diff changeset
4927 i+= 256;
92e94c550def h263 framerate & aspect ratio fixes
michael
parents: 1831
diff changeset
4928 s->picture_number= (s->picture_number&~0xFF) + i;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4929
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4930 /* PTYPE starts here */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4931 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4932 /* marker */
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4933 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4934 return -1;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4935 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4936 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4937 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4938 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4939 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4940 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4941 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4942 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4943
986e461dc072 Initial revision
glantau
parents:
diff changeset
4944 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4945 /*
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4946 0 forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4947 1 sub-QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4948 10 QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4949 7 extended PTYPE (PLUSPTYPE)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4950 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4951
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4952 if (format != 7 && format != 6) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4953 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4954 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4955 width = h263_format[format][0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4956 height = h263_format[format][1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4957 if (!width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4958 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4959
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4960 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4961
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
4962 s->h263_long_vectors = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4963
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4964 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4965 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4966 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4967 }
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
4968 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
4969 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4970
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4971 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4972 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4973 return -1; /* not PB frame */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4974 }
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4975 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4976 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1393
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1390
diff changeset
4977
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1390
diff changeset
4978 s->width = width;
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1390
diff changeset
4979 s->height = height;
1865
92e94c550def h263 framerate & aspect ratio fixes
michael
parents: 1831
diff changeset
4980 s->avctx->sample_aspect_ratio= (AVRational){12,11};
92e94c550def h263 framerate & aspect ratio fixes
michael
parents: 1831
diff changeset
4981 s->avctx->frame_rate = 30000;
92e94c550def h263 framerate & aspect ratio fixes
michael
parents: 1831
diff changeset
4982 s->avctx->frame_rate_base= 1001;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4983 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4984 int ufep;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4985
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4986 /* H.263v2 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4987 s->h263_plus = 1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4988 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4989
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4990 /* ufep other than 0 and 1 are reserved */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4991 if (ufep == 1) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4992 /* OPPTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4993 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4994 dprintf("ufep=1, format: %d\n", format);
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
4995 s->custom_pcf= get_bits1(&s->gb);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4996 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4997 if (get_bits1(&s->gb) != 0) {
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4998 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4999 }
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5000 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5001 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5002 s->loop_filter= get_bits1(&s->gb);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5003 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5004
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5005 s->h263_slice_structured= get_bits1(&s->gb);
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5006 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5007 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
5008 }
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5009 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5010 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
5011 }
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
5012 s->alt_inter_vlc= get_bits1(&s->gb);
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
5013 s->modified_quant= get_bits1(&s->gb);
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5014 if(s->modified_quant)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5015 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5016
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5017 skip_bits(&s->gb, 1); /* Prevent start code emulation */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5018
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5019 skip_bits(&s->gb, 3); /* Reserved */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5020 } else if (ufep != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5021 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5022 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5023 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5024
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
5025 /* MPPTYPE */
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
5026 s->pict_type = get_bits(&s->gb, 3);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
5027 switch(s->pict_type){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
5028 case 0: s->pict_type= I_TYPE;break;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
5029 case 1: s->pict_type= P_TYPE;break;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
5030 case 3: s->pict_type= B_TYPE;break;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
5031 case 7: s->pict_type= I_TYPE;break; //ZYGO
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
5032 default:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5033 return -1;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
5034 }
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
5035 skip_bits(&s->gb, 2);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
5036 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
5037 skip_bits(&s->gb, 4);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
5038
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
5039 /* Get the picture dimensions */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5040 if (ufep) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5041 if (format == 6) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5042 /* Custom Picture Format (CPFMT) */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5043 s->aspect_ratio_info = get_bits(&s->gb, 4);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5044 dprintf("aspect: %d\n", s->aspect_ratio_info);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5045 /* aspect ratios:
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5046 0 - forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5047 1 - 1:1
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5048 2 - 12:11 (CIF 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5049 3 - 10:11 (525-type 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5050 4 - 16:11 (CIF 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5051 5 - 40:33 (525-type 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5052 6-14 - reserved
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5053 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5054 width = (get_bits(&s->gb, 9) + 1) * 4;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5055 skip_bits1(&s->gb);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5056 height = get_bits(&s->gb, 9) * 4;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5057 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
5058 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5059 /* aspected dimensions */
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5060 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5061 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
5062 }else{
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5063 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5064 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5065 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5066 width = h263_format[format][0];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5067 height = h263_format[format][1];
1865
92e94c550def h263 framerate & aspect ratio fixes
michael
parents: 1831
diff changeset
5068 s->avctx->sample_aspect_ratio= (AVRational){12,11};
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5069 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5070 if ((width == 0) || (height == 0))
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5071 return -1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5072 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5073 s->height = height;
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5074
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5075 if(s->custom_pcf){
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5076 int gcd;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5077 s->avctx->frame_rate= 1800000;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5078 s->avctx->frame_rate_base= 1000 + get_bits1(&s->gb);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5079 s->avctx->frame_rate_base*= get_bits(&s->gb, 7);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5080 if(s->avctx->frame_rate_base == 0){
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5081 av_log(s, AV_LOG_ERROR, "zero framerate\n");
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5082 return -1;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5083 }
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5084 gcd= ff_gcd(s->avctx->frame_rate, s->avctx->frame_rate_base);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5085 s->avctx->frame_rate /= gcd;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5086 s->avctx->frame_rate_base /= gcd;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5087 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->frame_rate, s->avctx->frame_rate_base);
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5088 }else{
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5089 s->avctx->frame_rate = 30000;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5090 s->avctx->frame_rate_base= 1001;
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5091 }
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5092 }
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5093
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5094 if(s->custom_pcf){
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5095 skip_bits(&s->gb, 2); //extended Temporal reference
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5096 }
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5097
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5098 if (ufep) {
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
5099 if (s->umvplus) {
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
5100 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
5101 skip_bits1(&s->gb);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5102 }
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5103 if(s->h263_slice_structured){
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5104 if (get_bits1(&s->gb) != 0) {
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5105 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5106 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5107 if (get_bits1(&s->gb) != 0) {
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5108 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5109 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5110 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
5111 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
5112
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5113 s->qscale = get_bits(&s->gb, 5);
986e461dc072 Initial revision
glantau
parents:
diff changeset
5114 }
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5115
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
5116 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
5117 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
5118 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
5119
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5120 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5121 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5122 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5123 }
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
5124
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5125 if(s->h263_slice_structured){
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5126 if (get_bits1(&s->gb) != 1) {
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5127 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5128 return -1;
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5129 }
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5130
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5131 ff_h263_decode_mba(s);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5132
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5133 if (get_bits1(&s->gb) != 1) {
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5134 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5135 return -1;
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5136 }
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5137 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5138 s->f_code = 1;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5139
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5140 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5141 s->y_dc_scale_table=
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
5142 s->c_dc_scale_table= ff_aic_dc_scale_table;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5143 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5144 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5145 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5146 }
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5147
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5148 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5149 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",
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5150 s->qscale, av_get_pict_type_char(s->pict_type),
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5151 s->gb.size_in_bits, 1-s->no_rounding,
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5152 s->obmc ? " AP" : "",
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5153 s->umvplus ? " UMV" : "",
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5154 s->h263_long_vectors ? " LONG" : "",
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5155 s->h263_plus ? " +" : "",
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
5156 s->h263_aic ? " AIC" : "",
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
5157 s->alt_inter_vlc ? " AIV" : "",
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5158 s->modified_quant ? " MQ" : "",
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5159 s->loop_filter ? " LOOP" : "",
1872
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5160 s->h263_slice_structured ? " SS" : "",
c13d3543c73a h263+ custom pcf support
michael
parents: 1865
diff changeset
5161 s->avctx->frame_rate, s->avctx->frame_rate_base
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5162 );
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5163 }
1584
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5164 #if 1
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5165 if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5166 int i,j;
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5167 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
5168 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1584
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5169 for(i=0; i<13; i++){
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5170 for(j=0; j<3; j++){
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5171 int v= get_bits(&s->gb, 8);
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5172 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
5173 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
5174 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5175 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1584
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5176 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5177 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
5178 }
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5179 #endif
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5180
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5181 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5182 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5183
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
5184 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
5185 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5186 int i;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5187 int a= 2<<s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5188 int rho= 3-s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5189 int r=16/a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5190 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
5191 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
5192 int sprite_ref[4][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5193 int virtual_ref[2][2];
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5194 int w2, h2, w3, h3;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5195 int alpha=0, beta=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5196 int w= s->width;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5197 int h= s->height;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5198 int min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5199
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5200 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
5201 int length;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5202 int x=0, y=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5203
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
5204 length= get_vlc(gb, &sprite_trajectory);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5205 if(length){
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
5206 x= get_xbits(gb, length);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5207 }
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
5208 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5209
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
5210 length= get_vlc(gb, &sprite_trajectory);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5211 if(length){
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
5212 y=get_xbits(gb, length);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5213 }
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
5214 skip_bits1(gb); /* marker bit */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5215 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5216 d[i][0]= x;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5217 d[i][1]= y;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5218 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5219
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5220 while((1<<alpha)<w) alpha++;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5221 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
5222 w2= 1<<alpha;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5223 h2= 1<<beta;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5224
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5225 // Note, the 4th point isnt used for GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5226 if(s->divx_version==500 && s->divx_build==413){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5227 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5228 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5229 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5230 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5231 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5232 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5233 } else {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5234 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5235 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5236 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5237 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5238 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5239 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5240 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5241 /* 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
5242 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5243
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5244 // 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
5245 // 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
5246 // 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
5247 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5248 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
5249 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5250 virtual_ref[0][1]= 16*vop_ref[0][1]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
5251 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5252 virtual_ref[1][0]= 16*vop_ref[0][0]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
5253 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5254 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
5255 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5256
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5257 switch(s->num_sprite_warping_points)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5258 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5259 case 0:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5260 s->sprite_offset[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5261 s->sprite_offset[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5262 s->sprite_offset[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5263 s->sprite_offset[1][1]= 0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5264 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5265 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5266 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5267 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5268 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5269 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5270 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5271 case 1: //GMC only
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5272 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
5273 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
5274 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
5275 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5276 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5277 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5278 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5279 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5280 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5281 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5282 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5283 case 2:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5284 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5285 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5286 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5287 + (1<<(alpha+rho-1));
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5288 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5289 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5290 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5291 + (1<<(alpha+rho-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5292 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5293 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5294 +2*w2*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5295 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5296 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5297 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5298 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5299 +2*w2*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5300 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5301 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5302 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5303 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5304 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5305 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5306
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5307 s->sprite_shift[0]= alpha+rho;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5308 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
5309 break;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5310 case 3:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
5311 min_ab= FFMIN(alpha, beta);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5312 w3= w2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5313 h3= h2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5314 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5315 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5316 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5317 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5318 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5319 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5320 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5321 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5322 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5323 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5324 + 2*w2*h3*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5325 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5326 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5327 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5328 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5329 + 2*w2*h3*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5330 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5331 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5332 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5333 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5334 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5335 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5336
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5337 s->sprite_shift[0]= alpha + beta + rho - min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5338 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
5339 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5340 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5341 /* try to simplify the situation */
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5342 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5343 && s->sprite_delta[0][1] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5344 && s->sprite_delta[1][0] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5345 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5346 {
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5347 s->sprite_offset[0][0]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5348 s->sprite_offset[0][1]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5349 s->sprite_offset[1][0]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5350 s->sprite_offset[1][1]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5351 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5352 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5353 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5354 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5355 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5356 s->sprite_shift[1]= 0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5357 s->real_sprite_warping_points=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5358 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5359 else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5360 int shift_y= 16 - s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5361 int shift_c= 16 - s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5362 //printf("shifts %d %d\n", shift_y, shift_c);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5363 for(i=0; i<2; i++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5364 s->sprite_offset[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5365 s->sprite_offset[1][i]<<= shift_c;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5366 s->sprite_delta[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5367 s->sprite_delta[1][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5368 s->sprite_shift[i]= 16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5369 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5370 s->real_sprite_warping_points= s->num_sprite_warping_points;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5371 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5372 #if 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5373 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5374 vop_ref[0][0], vop_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5375 vop_ref[1][0], vop_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5376 vop_ref[2][0], vop_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5377 sprite_ref[0][0], sprite_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5378 sprite_ref[1][0], sprite_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5379 sprite_ref[2][0], sprite_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5380 virtual_ref[0][0], virtual_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5381 virtual_ref[1][0], virtual_ref[1][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5382 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5383
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5384 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5385 s->sprite_offset[0][0], s->sprite_offset[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5386 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5387 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5388 s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5389 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5390 #endif
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5391 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5392
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5393 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5394 int hours, minutes, seconds;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5395
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5396 hours= get_bits(gb, 5);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5397 minutes= get_bits(gb, 6);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5398 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5399 seconds= get_bits(gb, 6);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5400
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5401 s->time_base= seconds + 60*(minutes + 60*hours);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5402
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5403 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5404 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5405
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5406 return 0;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5407 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5408
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5409 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
5410 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
5411
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5412 /* vol header */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5413 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
5414 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
5415 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
5416 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
5417 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
5418 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5419 vo_ver_id = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5420 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5421 //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
5422 s->aspect_ratio_info= get_bits(gb, 4);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5423 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5424 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5425 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
5426 }else{
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5427 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
5428 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5429
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5430 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
5431 int chroma_format= get_bits(gb, 2);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5432 if(chroma_format!=1){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5433 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
5434 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5435 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
5436 if(get_bits1(gb)){ /* vbv parameters */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5437 get_bits(gb, 15); /* first_half_bitrate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5438 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5439 get_bits(gb, 15); /* latter_half_bitrate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5440 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5441 get_bits(gb, 15); /* first_half_vbv_buffer_size */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5442 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5443 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5444 get_bits(gb, 11); /* first_half_vbv_occupancy */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5445 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5446 get_bits(gb, 15); /* latter_half_vbv_occupancy */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5447 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5448 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5449 }else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5450 // set low delay flag only once so the smart? low delay detection wont be overriden
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5451 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5452 s->low_delay=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5453 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5454
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5455 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
5456 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
5457 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
5458 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
5459 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
5460 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5461
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5462 check_marker(gb, "before time_increment_resolution");
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5463
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5464 s->time_increment_resolution = get_bits(gb, 16);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5465
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5466 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5467 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
5468 s->time_increment_bits = 1;
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5469
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5470 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
5471
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5472 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5473 skip_bits(gb, s->time_increment_bits);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5474 }
2034
9629c1180d5f 10l (interlaced b frame decoding fix)
michael
parents: 2017
diff changeset
5475
9629c1180d5f 10l (interlaced b frame decoding fix)
michael
parents: 2017
diff changeset
5476 s->t_frame=0;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5477
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5478 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
5479 if (s->shape == RECT_SHAPE) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5480 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5481 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5482 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5483 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5484 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5485 if(width && height){ /* they should be non zero but who knows ... */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5486 s->width = width;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5487 s->height = height;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5488 // 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
5489 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5490 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5491
1659
3075fc11a974 AVFrame.interlaced_frame fixes
michael
parents: 1656
diff changeset
5492 s->progressive_sequence=
3075fc11a974 AVFrame.interlaced_frame fixes
michael
parents: 1656
diff changeset
5493 s->progressive_frame= get_bits1(gb)^1;
1237
6ce5cde4e1d4 print obmc bug info only if avctx->debug&1
michaelni
parents: 1177
diff changeset
5494 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5495 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
5496 if (vo_ver_id == 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5497 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
5498 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5499 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
5500 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5501 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
5502 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
5503 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
5504 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
5505 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5506 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
5507 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5508 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
5509 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5510 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
5511 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5512 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5513 s->num_sprite_warping_points= get_bits(gb, 6);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5514 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
5515 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
5516 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
5517 s->low_latency_sprite= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5518 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5519 // FIXME sadct disable bit if verid!=1 && shape not rect
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5520
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5521 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
5522 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
5523 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5524 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precission %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
5525 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5526 s->quant_precision = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5527 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5528
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5529 // 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
5530
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5531 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5532 int i, v;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5533
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5534 /* load default matrixes */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5535 for(i=0; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5536 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
5537 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
5538 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5539 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
5540
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5541 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
5542 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5543 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
5544 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5545
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5546 /* load custom intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5547 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5548 int last=0;
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5549 for(i=0; i<64; i++){
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5550 int j;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5551 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5552 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5553
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5554 last= v;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5555 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
5556 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5557 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
5558 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5559
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5560 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5561 for(; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5562 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5563 s->intra_matrix[j]= last;
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5564 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
5565 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5566 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5567
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5568 /* load custom non intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5569 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5570 int last=0;
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5571 for(i=0; i<64; i++){
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5572 int j;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5573 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5574 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5575
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5576 last= v;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5577 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
5578 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5579 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
5580 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5581
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5582 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5583 for(; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5584 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
5585 s->inter_matrix[j]= last;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5586 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
5587 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5588 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5589
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5590 // 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
5591 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5592
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5593 if(vo_ver_id != 1)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5594 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
5595 else s->quarter_sample=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5596
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5597 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5598
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5599 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
5600
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5601 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
5602 if(s->data_partitioning){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5603 s->rvlc= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5604 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5605
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5606 if(vo_ver_id != 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5607 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
5608 if(s->new_pred){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5609 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
5610 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
5611 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
5612 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5613 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
5614 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
5615 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5616 else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5617 s->new_pred=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5618 s->reduced_res_vop= 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5619 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5620
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5621 s->scalability= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5622
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5623 if (s->scalability) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5624 GetBitContext bak= *gb;
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5625 int ref_layer_id;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5626 int ref_layer_sampling_dir;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5627 int h_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5628 int h_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5629 int v_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5630 int v_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5631
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5632 s->hierachy_type= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5633 ref_layer_id= get_bits(gb, 4);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5634 ref_layer_sampling_dir= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5635 h_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5636 h_sampling_factor_m= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5637 v_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5638 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
5639 s->enhancement_type= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5640
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5641 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5642 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5643
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5644 // 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
5645 s->scalability=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5646
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5647 *gb= bak;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5648 }else
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5649 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5650
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5651 // bin shape stuff FIXME
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5652 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5653 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5654 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5655 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5656
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
5657 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
5658 * decodes the user data stuff in the header.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
5659 * allso inits divx/xvid/lavc_version/build
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
5660 */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5661 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
5662 char buf[256];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5663 int i;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5664 int e;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5665 int ver, build, ver2, ver3;
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
5666 char last;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5667
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5668 buf[0]= show_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5669 for(i=1; i<256; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5670 buf[i]= show_bits(gb, 16)&0xFF;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5671 if(buf[i]==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5672 skip_bits(gb, 8);
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 buf[255]=0;
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
5675
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5676 /* 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
5677 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
5678 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
5679 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
5680 if(e>=2){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5681 s->divx_version= ver;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5682 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
5683 s->divx_packed= e==3 && last=='p';
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5684 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5685
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5686 /* ffmpeg detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5687 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5688 if(e!=4)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5689 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5690 if(e!=4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5691 if(strcmp(buf, "ffmpeg")==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5692 s->ffmpeg_version= 0x000406;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5693 s->lavc_build= 4600;
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5694 }
747
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 if(e==4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5697 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5698 s->lavc_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5699 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5700
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5701 /* xvid detection */
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5702 e=sscanf(buf, "XviD%d", &build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5703 if(e==1){
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5704 s->xvid_build= build;
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5705 }
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5706
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5707 //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
5708 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5709 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5710
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5711 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
5712 int time_incr, time_increment;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5713
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5714 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
1346
44c94325810c CODEC_FLAG_LOW_DELAY fix
michaelni
parents: 1278
diff changeset
5715 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5716 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set, but shouldnt, clearing it\n");
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
5717 s->low_delay=0;
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
5718 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5719
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5720 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5721 if(s->partitioned_frame)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5722 s->decode_mb= mpeg4_decode_partitioned_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5723 else
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
5724 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
5725
662
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
5726 if(s->time_increment_resolution==0){
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
5727 s->time_increment_resolution=1;
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
5728 // fprintf(stderr, "time_increment_resolution is illegal\n");
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
5729 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5730 time_incr=0;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5731 while (get_bits1(gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5732 time_incr++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5733
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5734 check_marker(gb, "before time_increment");
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5735
1396
e380ac39024a cleanup / fixes
michaelni
parents: 1393
diff changeset
5736 if(s->time_increment_bits==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5737 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5738
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5739 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5740 if(show_bits(gb, s->time_increment_bits+1)&1) break;
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5741 }
1396
e380ac39024a cleanup / fixes
michaelni
parents: 1393
diff changeset
5742
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5743 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5744 }
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5745
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5746 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5747 else time_increment= get_bits(gb, s->time_increment_bits);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5748
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5749 // printf("%d %X\n", s->time_increment_bits, time_increment);
2034
9629c1180d5f 10l (interlaced b frame decoding fix)
michael
parents: 2017
diff changeset
5750 //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);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5751 if(s->pict_type!=B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5752 s->last_time_base= s->time_base;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5753 s->time_base+= time_incr;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5754 s->time= s->time_base*s->time_increment_resolution + time_increment;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5755 if(s->workaround_bugs&FF_BUG_UMP4){
700
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5756 if(s->time < s->last_non_b_time){
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5757 // 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
5758 s->time_base++;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5759 s->time+= s->time_increment_resolution;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5760 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5761 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5762 s->pp_time= s->time - s->last_non_b_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5763 s->last_non_b_time= s->time;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5764 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5765 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5766 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5767 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
335
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
5768 // printf("messed up order, seeking?, skiping current b frame\n");
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
5769 return FRAME_SKIPED;
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
5770 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5771
2034
9629c1180d5f 10l (interlaced b frame decoding fix)
michael
parents: 2017
diff changeset
5772 if(s->t_frame==0) s->t_frame= s->pb_time;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5773 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5774 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5775 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5776 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5777 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5778 }
2034
9629c1180d5f 10l (interlaced b frame decoding fix)
michael
parents: 2017
diff changeset
5779 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %Ld last_base %d time %Ld 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);
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
5780
1831
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
5781 s->current_picture_ptr->pts= s->time*(int64_t)AV_TIME_BASE / s->time_increment_resolution;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5782 if(s->avctx->debug&FF_DEBUG_PTS)
1831
cd2d7fcfab7a use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents: 1829
diff changeset
5783 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %f\n", s->current_picture_ptr->pts/(float)AV_TIME_BASE);
2034
9629c1180d5f 10l (interlaced b frame decoding fix)
michael
parents: 2017
diff changeset
5784
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5785 check_marker(gb, "before vop_coded");
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5786
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5787 /* vop coded */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5788 if (get_bits1(gb) != 1){
2271
859535b5eb57 dont print "vop not coded" by default
michael
parents: 2253
diff changeset
5789 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
859535b5eb57 dont print "vop not coded" by default
michael
parents: 2253
diff changeset
5790 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5791 return FRAME_SKIPED;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5792 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5793 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5794 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5795 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5796 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5797 /* rounding type for motion estimation */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5798 s->no_rounding = get_bits1(gb);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5799 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5800 s->no_rounding = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5801 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5802 //FIXME reduced res stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5803
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5804 if (s->shape != RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5805 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5806 int width, height, hor_spat_ref, ver_spat_ref;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5807
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5808 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5809 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5810 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5811 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5812 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
5813 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5814 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5815 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5816 skip_bits1(gb); /* change_CR_disable */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5817
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5818 if (get_bits1(gb) != 0) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5819 skip_bits(gb, 8); /* constant_alpha_value */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5820 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5821 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5822 //FIXME complexity estimation stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5823
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5824 if (s->shape != BIN_ONLY_SHAPE) {
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
5825 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
5826 if(!s->progressive_sequence){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5827 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
5828 s->alternate_scan= get_bits1(gb);
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
5829 }else
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
5830 s->alternate_scan= 0;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5831 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5832
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
5833 if(s->alternate_scan){
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5834 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5835 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5836 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5837 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
5838 } else{
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5839 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5840 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5841 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5842 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
5843 }
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
5844
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5845 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
1914
8337c46a5abe gmc segfault fix
michael
parents: 1912
diff changeset
5846 mpeg4_decode_sprite_trajectory(s, gb);
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5847 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
5848 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
5849 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5850
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5851 if (s->shape != BIN_ONLY_SHAPE) {
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5852 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
5853 if(s->qscale==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5854 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
5855 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
5856 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5857
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5858 if (s->pict_type != I_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5859 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
5860 if(s->f_code==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5861 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
5862 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
5863 }
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5864 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5865 s->f_code=1;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5866
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5867 if (s->pict_type == B_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5868 s->b_code = get_bits(gb, 3);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5869 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5870 s->b_code=1;
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5871
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5872 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
5873 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\n",
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5874 s->qscale, s->f_code, s->b_code,
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5875 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
5876 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
930
6bcb214d6a17 more debug output
michaelni
parents: 923
diff changeset
5877 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
5878 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5879 }
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5880
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5881 if(!s->scalability){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5882 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5883 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
5884 }
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5885 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5886 if(s->enhancement_type){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5887 int load_backward_shape= get_bits1(gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5888 if(load_backward_shape){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5889 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isnt supported\n");
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5890 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5891 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5892 skip_bits(gb, 2); //ref_select_code
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5893 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5894 }
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5895 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5896 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
5897 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
5898 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
5899 s->low_delay=1;
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5900 }
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5901
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5902 s->picture_number++; // better than pic number==0 allways ;)
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5903
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5904 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5905 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5906
1366
80067f8d6770 fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents: 1364
diff changeset
5907 if(s->workaround_bugs&FF_BUG_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5908 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5909 s->v_edge_pos= s->height;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5910 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5911 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5912 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5913
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5914 /**
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5915 * decode mpeg4 headers
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5916 * @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
5917 * 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
5918 * 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
5919 */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5920 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
5921 {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5922 int startcode, v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5923
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5924 /* search next start code */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5925 align_get_bits(gb);
2406
25a24139f296 WV1F support
michael
parents: 2370
diff changeset
5926
25a24139f296 WV1F support
michael
parents: 2370
diff changeset
5927 if(s->avctx->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
25a24139f296 WV1F support
michael
parents: 2370
diff changeset
5928 skip_bits(gb, 24);
25a24139f296 WV1F support
michael
parents: 2370
diff changeset
5929 if(get_bits(gb, 8) == 0xF0)
25a24139f296 WV1F support
michael
parents: 2370
diff changeset
5930 return decode_vop_header(s, gb);
25a24139f296 WV1F support
michael
parents: 2370
diff changeset
5931 }
25a24139f296 WV1F support
michael
parents: 2370
diff changeset
5932
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5933 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5934 for(;;) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5935 v = get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5936 startcode = ((startcode << 8) | v) & 0xffffffff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5937
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
5938 if(get_bits_count(gb) >= gb->size_in_bits){
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
5939 if(gb->size_in_bits==8 && s->divx_version){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5940 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5941 return FRAME_SKIPED; //divx bug
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5942 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5943 return -1; //end of stream
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5944 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5945
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5946 if((startcode&0xFFFFFF00) != 0x100)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5947 continue; //no startcode
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5948
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5949 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
5950 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
5951 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
5952 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
5953 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
5954 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
5955 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
5956 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
5957 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
5958 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
5959 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
5960 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
5961 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
5962 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
5963 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
5964 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
5965 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
5966 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
5967 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
5968 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
5969 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5970 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Textutre Object start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5971 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Spatial Layer start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5972 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Textutre SNR Layer start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5973 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Tile start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5974 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Shape Layer start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5975 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
5976 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
5977 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
5978 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5979 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5980
1512
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5981 if(startcode >= 0x120 && startcode <= 0x12F){
1396
e380ac39024a cleanup / fixes
michaelni
parents: 1393
diff changeset
5982 if(decode_vol_header(s, gb) < 0)
e380ac39024a cleanup / fixes
michaelni
parents: 1393
diff changeset
5983 return -1;
1512
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5984 }
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5985 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
5986 decode_user_data(s, gb);
1512
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5987 }
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5988 else if(startcode == GOP_STARTCODE){
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5989 mpeg4_decode_gop_header(s, gb);
1512
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5990 }
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5991 else if(startcode == VOP_STARTCODE){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5992 return decode_vop_header(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5993 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5994
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5995 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5996 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5997 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5998 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5999
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6000 /* don't understand why they choose a different header ! */
986e461dc072 Initial revision
glantau
parents:
diff changeset
6001 int intel_h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
6002 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
6003 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
6004
986e461dc072 Initial revision
glantau
parents:
diff changeset
6005 /* picture header */
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1255
diff changeset
6006 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
6007 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6008 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6009 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6010 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6011
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6012 if (get_bits1(&s->gb) != 1) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
6013 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6014 return -1; /* marker */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6015 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6016 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
6017 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6018 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6019 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6020 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6021 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6022 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6023
986e461dc072 Initial revision
glantau
parents:
diff changeset
6024 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6025 if (format != 7) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
6026 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6027 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6028 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6029 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
6030
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6031 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6032
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6033 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6034 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
6035
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6036 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
6037 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6038 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6039 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6040 if (get_bits1(&s->gb) != 0) {
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
6041 s->obmc= 1;
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
6042 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
6043 // return -1; /* advanced prediction mode: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6044 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6045 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
6046 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6047 return -1; /* PB frame mode */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
6048 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6049
986e461dc072 Initial revision
glantau
parents:
diff changeset
6050 /* skip unknown header garbage */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6051 skip_bits(&s->gb, 41);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6052
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
6053 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6054 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6055
986e461dc072 Initial revision
glantau
parents:
diff changeset
6056 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6057 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
6058 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6059 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
6060 s->f_code = 1;
770
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
6061
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
6062 s->y_dc_scale_table=
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
6063 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
6064
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
6065 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
6066 }
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
6067
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6068 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
6069 {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6070 int format, width, height;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6071
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6072 /* picture header */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6073 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
6074 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
6075 return -1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6076 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6077 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
6078 if (format != 0 && format != 1) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
6079 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
6080 return -1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6081 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6082 s->h263_flv = format+1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6083 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
6084 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
6085 switch (format) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6086 case 0:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6087 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
6088 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
6089 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6090 case 1:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6091 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
6092 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
6093 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6094 case 2:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6095 width = 352;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6096 height = 288;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6097 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6098 case 3:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6099 width = 176;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6100 height = 144;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6101 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6102 case 4:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6103 width = 128;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6104 height = 96;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6105 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6106 case 5:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6107 width = 320;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6108 height = 240;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6109 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6110 case 6:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6111 width = 160;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6112 height = 120;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6113 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6114 default:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6115 width = height = 0;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6116 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6117 }
2422
18b8b2dcc037 various security fixes and precautionary checks
michael
parents: 2414
diff changeset
6118 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
6119 return -1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6120 s->width = width;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6121 s->height = height;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6122
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6123 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
1944
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
6124 s->dropable= s->pict_type > P_TYPE;
a3f44c9168aa flv dropable p frame support
michael
parents: 1938
diff changeset
6125 if (s->dropable)
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6126 s->pict_type = P_TYPE;
2080
6a9472a09ffc coefficient saturation fix
michael
parents: 2034
diff changeset
6127
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6128 skip_bits1(&s->gb); /* deblocking flag */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
6129 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
6130
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6131 s->h263_plus = 0;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6132
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6133 s->unrestricted_mv = 1;
1364
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6134 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
6135
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6136 /* PEI */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6137 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
6138 skip_bits(&s->gb, 8);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6139 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6140 s->f_code = 1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6141
1364
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6142 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
6143 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
6144 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
1364
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6145 }
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6146
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6147 s->y_dc_scale_table=
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6148 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
6149
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6150 return 0;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6151 }