Mercurial > libavcodec.hg
annotate dv.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | f67b63ed036d |
children | 5e24800ab329 |
rev | line source |
---|---|
723 | 1 /* |
2 * DV decoder | |
3 * Copyright (c) 2002 Fabrice Bellard. | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
4 * Copyright (c) 2004 Roman Shaposhnik. |
723 | 5 * |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
6 * DV encoder |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
7 * Copyright (c) 2003 Roman Shaposhnik. |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
8 * |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
9 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
10 * of DV technical info. |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
11 * |
723 | 12 * This library is free software; you can redistribute it and/or |
13 * modify it under the terms of the GNU Lesser General Public | |
14 * License as published by the Free Software Foundation; either | |
15 * version 2 of the License, or (at your option) any later version. | |
16 * | |
17 * This library is distributed in the hope that it will be useful, | |
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
20 * Lesser General Public License for more details. | |
21 * | |
22 * You should have received a copy of the GNU Lesser General Public | |
23 * License along with this library; if not, write to the Free Software | |
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
25 */ | |
1106 | 26 |
27 /** | |
28 * @file dv.c | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
29 * DV codec. |
1106 | 30 */ |
723 | 31 #include "avcodec.h" |
32 #include "dsputil.h" | |
33 #include "mpegvideo.h" | |
34 #include "simple_idct.h" | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
35 #include "dvdata.h" |
723 | 36 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
37 typedef struct DVVideoContext { |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
38 const DVprofile* sys; |
925 | 39 AVFrame picture; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
40 uint8_t *buf; |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
41 |
1064 | 42 uint8_t dv_zigzag[2][64]; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
43 uint8_t dv_idct_shift[2][2][22][64]; |
1567 | 44 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
45 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); |
1567 | 46 void (*fdct[2])(DCTELEM *block); |
47 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block); | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
48 } DVVideoContext; |
723 | 49 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
50 #define TEX_VLC_BITS 9 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
51 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
52 #ifdef DV_CODEC_TINY_TARGET |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
53 #define DV_VLC_MAP_RUN_SIZE 15 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
54 #define DV_VLC_MAP_LEV_SIZE 23 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
55 #else |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
56 #define DV_VLC_MAP_RUN_SIZE 64 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
57 #define DV_VLC_MAP_LEV_SIZE 512 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
58 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
59 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
60 /* MultiThreading */ |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
61 static uint8_t** dv_anchor; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
62 |
723 | 63 /* XXX: also include quantization */ |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
64 static RL_VLC_ELEM *dv_rl_vlc; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
65 /* VLC encoding lookup table */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
66 static struct dv_vlc_pair { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
67 uint32_t vlc; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
68 uint8_t size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
69 } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL; |
723 | 70 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
71 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm) |
723 | 72 { |
725 | 73 int i, q, j; |
723 | 74 |
75 /* NOTE: max left shift is 6 */ | |
725 | 76 for(q = 0; q < 22; q++) { |
1567 | 77 /* 88DCT */ |
725 | 78 for(i = 1; i < 64; i++) { |
79 /* 88 table */ | |
1567 | 80 j = perm[i]; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
81 s->dv_idct_shift[0][0][q][j] = |
725 | 82 dv_quant_shifts[q][dv_88_areas[i]] + 1; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
83 s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1; |
725 | 84 } |
85 | |
1567 | 86 /* 248DCT */ |
725 | 87 for(i = 1; i < 64; i++) { |
88 /* 248 table */ | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
89 s->dv_idct_shift[0][1][q][i] = |
1567 | 90 dv_quant_shifts[q][dv_248_areas[i]] + 1; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
91 s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1; |
723 | 92 } |
93 } | |
94 } | |
95 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
96 static int dvvideo_init(AVCodecContext *avctx) |
723 | 97 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
98 DVVideoContext *s = avctx->priv_data; |
1567 | 99 DSPContext dsp; |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
100 static int done=0; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
101 int i, j; |
723 | 102 |
103 if (!done) { | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
104 VLC dv_vlc; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
105 uint16_t new_dv_vlc_bits[NB_DV_VLC*2]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
106 uint8_t new_dv_vlc_len[NB_DV_VLC*2]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
107 uint8_t new_dv_vlc_run[NB_DV_VLC*2]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
108 int16_t new_dv_vlc_level[NB_DV_VLC*2]; |
723 | 109 |
110 done = 1; | |
111 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
112 dv_vlc_map = av_mallocz(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair)); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
113 if (!dv_vlc_map) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
114 return -ENOMEM; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
115 |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
116 /* dv_anchor lets each thread know its Id */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
117 dv_anchor = av_malloc(12*27*sizeof(void*)); |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
118 if (!dv_anchor) { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
119 av_free(dv_vlc_map); |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
120 return -ENOMEM; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
121 } |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
122 for (i=0; i<12*27; i++) |
1904 | 123 dv_anchor[i] = (void*)(size_t)i; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
124 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
125 /* it's faster to include sign bit in a generic VLC parsing scheme */ |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
126 for (i=0, j=0; i<NB_DV_VLC; i++, j++) { |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
127 new_dv_vlc_bits[j] = dv_vlc_bits[i]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
128 new_dv_vlc_len[j] = dv_vlc_len[i]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
129 new_dv_vlc_run[j] = dv_vlc_run[i]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
130 new_dv_vlc_level[j] = dv_vlc_level[i]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
131 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
132 if (dv_vlc_level[i]) { |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
133 new_dv_vlc_bits[j] <<= 1; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
134 new_dv_vlc_len[j]++; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
135 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
136 j++; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
137 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
138 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
139 new_dv_vlc_run[j] = dv_vlc_run[i]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
140 new_dv_vlc_level[j] = -dv_vlc_level[i]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
141 } |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
142 } |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
143 |
723 | 144 /* NOTE: as a trick, we use the fact the no codes are unused |
145 to accelerate the parsing of partial codes */ | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
146 init_vlc(&dv_vlc, TEX_VLC_BITS, j, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2247
diff
changeset
|
147 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); |
723 | 148 |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
149 dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM)); |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
150 if (!dv_rl_vlc) { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
151 av_free(dv_anchor); |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
152 av_free(dv_vlc_map); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
153 return -ENOMEM; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
154 } |
723 | 155 for(i = 0; i < dv_vlc.table_size; i++){ |
156 int code= dv_vlc.table[i][0]; | |
157 int len = dv_vlc.table[i][1]; | |
158 int level, run; | |
159 | |
160 if(len<0){ //more bits needed | |
161 run= 0; | |
162 level= code; | |
163 } else { | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
164 run= new_dv_vlc_run[code] + 1; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
165 level= new_dv_vlc_level[code]; |
723 | 166 } |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
167 dv_rl_vlc[i].len = len; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
168 dv_rl_vlc[i].level = level; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
169 dv_rl_vlc[i].run = run; |
723 | 170 } |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
171 free_vlc(&dv_vlc); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
172 |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
173 for (i = 0; i < NB_DV_VLC - 1; i++) { |
2027
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
174 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
175 continue; |
2027
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
176 #ifdef DV_CODEC_TINY_TARGET |
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
177 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) |
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
178 continue; |
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
179 #endif |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
180 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
181 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
182 continue; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
183 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
184 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
185 (!!dv_vlc_level[i]); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
186 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
187 (!!dv_vlc_level[i]); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
188 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
189 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
190 #ifdef DV_CODEC_TINY_TARGET |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
191 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
192 if (dv_vlc_map[i][j].size == 0) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
193 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
194 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
195 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
196 dv_vlc_map[0][j].size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
197 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
198 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
199 #else |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
200 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
201 if (dv_vlc_map[i][j].size == 0) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
202 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
203 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
204 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
205 dv_vlc_map[0][j].size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
206 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
207 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
208 dv_vlc_map[i][j].vlc | 1; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
209 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
210 dv_vlc_map[i][j].size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
211 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
212 #endif |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
213 } |
723 | 214 } |
725 | 215 |
1567 | 216 /* Generic DSP setup */ |
217 dsputil_init(&dsp, avctx); | |
218 s->get_pixels = dsp.get_pixels; | |
725 | 219 |
1567 | 220 /* 88DCT setup */ |
221 s->fdct[0] = dsp.fdct; | |
222 s->idct_put[0] = dsp.idct_put; | |
223 for (i=0; i<64; i++) | |
224 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]]; | |
725 | 225 |
1567 | 226 /* 248DCT setup */ |
227 s->fdct[1] = dsp.fdct248; | |
228 s->idct_put[1] = simple_idct248_put; // FIXME: need to add it to DSP | |
229 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); | |
725 | 230 |
723 | 231 /* XXX: do it only for constant case */ |
1567 | 232 dv_build_unquantize_tables(s, dsp.idct_permutation); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
233 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
234 /* FIXME: I really don't think this should be here */ |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
235 if (dv_codec_profile(avctx)) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
236 avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt; |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
237 avctx->coded_frame = &s->picture; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
238 |
723 | 239 return 0; |
240 } | |
241 | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
242 // #define VLC_DEBUG |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
243 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__) |
723 | 244 |
725 | 245 typedef struct BlockInfo { |
1064 | 246 const uint8_t *shift_table; |
247 const uint8_t *scan_table; | |
248 uint8_t pos; /* position in block */ | |
249 uint8_t dct_mode; | |
250 uint8_t partial_bit_count; | |
251 uint16_t partial_bit_buffer; | |
725 | 252 int shift_offset; |
253 } BlockInfo; | |
723 | 254 |
255 /* block size in bits */ | |
1064 | 256 static const uint16_t block_sizes[6] = { |
723 | 257 112, 112, 112, 112, 80, 80 |
258 }; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
259 /* bit budget for AC only in 5 MBs */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
260 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
261 /* see dv_88_areas and dv_248_areas for details */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
262 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; |
723 | 263 |
264 #ifndef ALT_BITSTREAM_READER | |
1256
b8e1c17b8d7d
some libmpeg2 style bitstream reader fixes (no dv doesnt yet work with it)
michaelni
parents:
1228
diff
changeset
|
265 #warning only works with ALT_BITSTREAM_READER |
723 | 266 #endif |
267 | |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
268 static inline int get_bits_left(GetBitContext *s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
269 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
270 return s->size_in_bits - get_bits_count(s); |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
271 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
272 |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
273 static inline int get_bits_size(GetBitContext *s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
274 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
275 return s->size_in_bits; |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
276 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
277 |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
278 static inline int put_bits_left(PutBitContext* s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
279 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
280 return (s->buf_end - s->buf) * 8 - put_bits_count(s); |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
281 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
282 |
723 | 283 /* decode ac coefs */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
284 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) |
723 | 285 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
286 int last_index = get_bits_size(gb); |
1064 | 287 const uint8_t *scan_table = mb->scan_table; |
288 const uint8_t *shift_table = mb->shift_table; | |
725 | 289 int pos = mb->pos; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
290 int partial_bit_count = mb->partial_bit_count; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
291 int level, pos1, run, vlc_len, index; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
292 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
293 OPEN_READER(re, gb); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
294 UPDATE_CACHE(re, gb); |
723 | 295 |
296 /* if we must parse a partial vlc, we do it here */ | |
297 if (partial_bit_count > 0) { | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
298 re_cache = ((unsigned)re_cache >> partial_bit_count) | |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
299 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count)); |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
300 re_index -= partial_bit_count; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
301 mb->partial_bit_count = 0; |
723 | 302 } |
303 | |
304 /* get the AC coefficients until last_index is reached */ | |
305 for(;;) { | |
306 #ifdef VLC_DEBUG | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
307 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); |
723 | 308 #endif |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
309 /* our own optimized GET_RL_VLC */ |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
310 index = NEG_USR32(re_cache, TEX_VLC_BITS); |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
311 vlc_len = dv_rl_vlc[index].len; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
312 if (vlc_len < 0) { |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
313 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
314 vlc_len = TEX_VLC_BITS - vlc_len; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
315 } |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
316 level = dv_rl_vlc[index].level; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
317 run = dv_rl_vlc[index].run; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
318 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
319 /* gotta check if we're still within gb boundaries */ |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
320 if (re_index + vlc_len > last_index) { |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
321 /* should be < 16 bits otherwise a codeword could have been parsed */ |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
322 mb->partial_bit_count = last_index - re_index; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
323 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
324 re_index = last_index; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
325 break; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
326 } |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
327 re_index += vlc_len; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
328 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
329 #ifdef VLC_DEBUG |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
330 printf("run=%d level=%d\n", run, level); |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
331 #endif |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
332 pos += run; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
333 if (pos >= 64) |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
334 break; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
335 |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
336 if (level) { |
723 | 337 pos1 = scan_table[pos]; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
338 block[pos1] = level << shift_table[pos1]; |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
339 } |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
340 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
341 UPDATE_CACHE(re, gb); |
723 | 342 } |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
343 CLOSE_READER(re, gb); |
725 | 344 mb->pos = pos; |
723 | 345 } |
346 | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
347 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) |
723 | 348 { |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
349 int bits_left = get_bits_left(gb); |
723 | 350 while (bits_left >= 16) { |
351 put_bits(pb, 16, get_bits(gb, 16)); | |
352 bits_left -= 16; | |
353 } | |
354 if (bits_left > 0) { | |
355 put_bits(pb, bits_left, get_bits(gb, bits_left)); | |
356 } | |
357 } | |
358 | |
359 /* mb_x and mb_y are in units of 8 pixels */ | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
360 static inline void dv_decode_video_segment(DVVideoContext *s, |
1064 | 361 uint8_t *buf_ptr1, |
362 const uint16_t *mb_pos_ptr) | |
723 | 363 { |
364 int quant, dc, dct_mode, class1, j; | |
365 int mb_index, mb_x, mb_y, v, last_index; | |
366 DCTELEM *block, *block1; | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
367 int c_offset; |
1064 | 368 uint8_t *y_ptr; |
369 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); | |
370 uint8_t *buf_ptr; | |
723 | 371 PutBitContext pb, vs_pb; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
372 GetBitContext gb; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
373 BlockInfo mb_data[5 * 6], *mb, *mb1; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
374 DCTELEM sblock[5*6][64] __align8; |
1064 | 375 uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */ |
376 uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */ | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
377 |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
378 memset(sblock, 0, sizeof(sblock)); |
723 | 379 |
380 /* pass 1 : read DC and AC coefficients in blocks */ | |
381 buf_ptr = buf_ptr1; | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
382 block1 = &sblock[0][0]; |
725 | 383 mb1 = mb_data; |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
384 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
385 for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) { |
723 | 386 /* skip header */ |
387 quant = buf_ptr[3] & 0x0f; | |
388 buf_ptr += 4; | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
389 init_put_bits(&pb, mb_bit_buffer, 80); |
725 | 390 mb = mb1; |
723 | 391 block = block1; |
392 for(j = 0;j < 6; j++) { | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
393 last_index = block_sizes[j]; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
394 init_get_bits(&gb, buf_ptr, last_index); |
723 | 395 |
396 /* get the dc */ | |
2247 | 397 dc = get_sbits(&gb, 9); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
398 dct_mode = get_bits1(&gb); |
725 | 399 mb->dct_mode = dct_mode; |
400 mb->scan_table = s->dv_zigzag[dct_mode]; | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
401 class1 = get_bits(&gb, 2); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
402 mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode] |
723 | 403 [quant + dv_quant_offset[class1]]; |
404 dc = dc << 2; | |
405 /* convert to unsigned because 128 is not added in the | |
406 standard IDCT */ | |
407 dc += 1024; | |
408 block[0] = dc; | |
409 buf_ptr += last_index >> 3; | |
725 | 410 mb->pos = 0; |
411 mb->partial_bit_count = 0; | |
723 | 412 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
413 #ifdef VLC_DEBUG |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
414 printf("MB block: %d, %d ", mb_index, j); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
415 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
416 dv_decode_ac(&gb, mb, block); |
723 | 417 |
418 /* write the remaining bits in a new buffer only if the | |
419 block is finished */ | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
420 if (mb->pos >= 64) |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
421 bit_copy(&pb, &gb); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
422 |
723 | 423 block += 64; |
725 | 424 mb++; |
723 | 425 } |
426 | |
427 /* pass 2 : we can do it just after */ | |
428 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
429 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); |
723 | 430 #endif |
431 block = block1; | |
725 | 432 mb = mb1; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
433 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
434 flush_put_bits(&pb); |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
435 for(j = 0;j < 6; j++, block += 64, mb++) { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
436 if (mb->pos < 64 && get_bits_left(&gb) > 0) { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
437 dv_decode_ac(&gb, mb, block); |
723 | 438 /* if still not finished, no need to parse other blocks */ |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
439 if (mb->pos < 64) |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
440 break; |
723 | 441 } |
442 } | |
443 /* all blocks are finished, so the extra bytes can be used at | |
444 the video segment level */ | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
445 if (j >= 6) |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
446 bit_copy(&vs_pb, &gb); |
723 | 447 } |
448 | |
449 /* we need a pass other the whole video segment */ | |
450 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
451 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); |
723 | 452 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
453 block = &sblock[0][0]; |
723 | 454 mb = mb_data; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
455 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb)); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
456 flush_put_bits(&vs_pb); |
723 | 457 for(mb_index = 0; mb_index < 5; mb_index++) { |
458 for(j = 0;j < 6; j++) { | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
459 if (mb->pos < 64) { |
723 | 460 #ifdef VLC_DEBUG |
461 printf("start %d:%d\n", mb_index, j); | |
462 #endif | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
463 dv_decode_ac(&gb, mb, block); |
723 | 464 } |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
465 if (mb->pos >= 64 && mb->pos < 127) |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
466 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); |
723 | 467 block += 64; |
725 | 468 mb++; |
723 | 469 } |
470 } | |
471 | |
472 /* compute idct and place blocks */ | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
473 block = &sblock[0][0]; |
723 | 474 mb = mb_data; |
475 for(mb_index = 0; mb_index < 5; mb_index++) { | |
476 v = *mb_pos_ptr++; | |
477 mb_x = v & 0xff; | |
478 mb_y = v >> 8; | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
479 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8); |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
480 if (s->sys->pix_fmt == PIX_FMT_YUV411P) |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
481 c_offset = (mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8); |
723 | 482 else |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
483 c_offset = ((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8); |
723 | 484 for(j = 0;j < 6; j++) { |
725 | 485 idct_put = s->idct_put[mb->dct_mode]; |
723 | 486 if (j < 4) { |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
487 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { |
737 | 488 /* NOTE: at end of line, the macroblock is handled as 420 */ |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
489 idct_put(y_ptr + (j * 8), s->picture.linesize[0], block); |
723 | 490 } else { |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
491 idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]), |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
492 s->picture.linesize[0], block); |
723 | 493 } |
494 } else { | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
495 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
1540 | 496 uint64_t aligned_pixels[64/8]; |
1537 | 497 uint8_t *pixels= (uint8_t*)aligned_pixels; |
1540 | 498 uint8_t *c_ptr, *c_ptr1, *ptr; |
737 | 499 int y, linesize; |
500 /* NOTE: at end of line, the macroblock is handled as 420 */ | |
501 idct_put(pixels, 8, block); | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
502 linesize = s->picture.linesize[6 - j]; |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
503 c_ptr = s->picture.data[6 - j] + c_offset; |
737 | 504 ptr = pixels; |
505 for(y = 0;y < 8; y++) { | |
506 /* convert to 411P */ | |
1270
f5318caa93f4
seems i guessed correctly (last 411 chroma block isnt scaled but cut and reordered)
michaelni
parents:
1256
diff
changeset
|
507 c_ptr1 = c_ptr + 8*linesize; |
f5318caa93f4
seems i guessed correctly (last 411 chroma block isnt scaled but cut and reordered)
michaelni
parents:
1256
diff
changeset
|
508 c_ptr[0]= ptr[0]; c_ptr1[0]= ptr[4]; |
f5318caa93f4
seems i guessed correctly (last 411 chroma block isnt scaled but cut and reordered)
michaelni
parents:
1256
diff
changeset
|
509 c_ptr[1]= ptr[1]; c_ptr1[1]= ptr[5]; |
f5318caa93f4
seems i guessed correctly (last 411 chroma block isnt scaled but cut and reordered)
michaelni
parents:
1256
diff
changeset
|
510 c_ptr[2]= ptr[2]; c_ptr1[2]= ptr[6]; |
f5318caa93f4
seems i guessed correctly (last 411 chroma block isnt scaled but cut and reordered)
michaelni
parents:
1256
diff
changeset
|
511 c_ptr[3]= ptr[3]; c_ptr1[3]= ptr[7]; |
f5318caa93f4
seems i guessed correctly (last 411 chroma block isnt scaled but cut and reordered)
michaelni
parents:
1256
diff
changeset
|
512 c_ptr += linesize; |
737 | 513 ptr += 8; |
514 } | |
515 } else { | |
516 /* don't ask me why they inverted Cb and Cr ! */ | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
517 idct_put(s->picture.data[6 - j] + c_offset, |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
518 s->picture.linesize[6 - j], block); |
737 | 519 } |
723 | 520 } |
521 block += 64; | |
725 | 522 mb++; |
723 | 523 } |
524 } | |
525 } | |
526 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
527 #ifdef DV_CODEC_TINY_TARGET |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
528 /* Converts run and level (where level != 0) pair into vlc, returning bit size */ |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
529 static always_inline int dv_rl2vlc(int run, int l, uint32_t* vlc) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
530 { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
531 int sign = l >> 8; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
532 int level = (l ^ sign) - sign; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
533 int size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
534 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
535 sign = (sign & 1); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
536 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
537 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
538 *vlc = dv_vlc_map[run][level].vlc | sign; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
539 size = dv_vlc_map[run][level].size; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
540 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
541 else { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
542 if (level < DV_VLC_MAP_LEV_SIZE) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
543 *vlc = dv_vlc_map[0][level].vlc | sign; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
544 size = dv_vlc_map[0][level].size; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
545 } else { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
546 *vlc = 0xfe00 | (level << 1) | sign; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
547 size = 16; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
548 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
549 if (run) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
550 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
551 (0x1f80 | (run - 1))) << size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
552 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
553 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
554 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
555 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
556 return size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
557 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
558 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
559 static always_inline int dv_rl2vlc_size(int run, int l) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
560 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
561 int level = (l ^ (l >> 8)) - (l >> 8); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
562 int size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
563 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
564 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
565 size = dv_vlc_map[run][level].size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
566 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
567 else { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
568 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
569 if (run) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
570 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
571 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
572 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
573 return size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
574 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
575 #else |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
576 static always_inline int dv_rl2vlc(int run, int l, uint32_t* vlc) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
577 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
578 *vlc = dv_vlc_map[run][((uint16_t)l)&0x1ff].vlc; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
579 return dv_vlc_map[run][((uint16_t)l)&0x1ff].size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
580 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
581 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
582 static always_inline int dv_rl2vlc_size(int run, int l) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
583 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
584 return dv_vlc_map[run][((uint16_t)l)&0x1ff].size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
585 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
586 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
587 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
588 typedef struct EncBlockInfo { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
589 int area_q[4]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
590 int bit_size[4]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
591 int prev_run[4]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
592 int cur_ac; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
593 int cno; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
594 int dct_mode; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
595 DCTELEM *mb; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
596 uint8_t partial_bit_count; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
597 uint32_t partial_bit_buffer; /* we can't use uint16_t here */ |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
598 } EncBlockInfo; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
599 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
600 static always_inline void dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool, |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
601 int pb_size) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
602 { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
603 int run; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
604 int bits_left; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
605 PutBitContext* pb = pb_pool; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
606 int size = bi->partial_bit_count; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
607 uint32_t vlc = bi->partial_bit_buffer; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
608 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
609 bi->partial_bit_count = bi->partial_bit_buffer = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
610 vlc_loop: |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
611 /* Find suitable storage space */ |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1726
diff
changeset
|
612 for (; size > (bits_left = put_bits_left(pb)); pb++) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
613 if (bits_left) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
614 size -= bits_left; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
615 put_bits(pb, bits_left, vlc >> size); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
616 vlc = vlc & ((1<<size)-1); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
617 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
618 if (pb_size == 1) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
619 bi->partial_bit_count = size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
620 bi->partial_bit_buffer = vlc; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
621 return; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
622 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
623 --pb_size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
624 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
625 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
626 /* Store VLC */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
627 put_bits(pb, size, vlc); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
628 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
629 /* Construct the next VLC */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
630 run = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
631 for (; bi->cur_ac < 64; bi->cur_ac++, run++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
632 if (bi->mb[bi->cur_ac]) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
633 size = dv_rl2vlc(run, bi->mb[bi->cur_ac], &vlc); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
634 bi->cur_ac++; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
635 goto vlc_loop; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
636 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
637 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
638 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
639 if (bi->cur_ac == 64) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
640 size = 4; vlc = 6; /* End Of Block stamp */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
641 bi->cur_ac++; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
642 goto vlc_loop; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
643 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
644 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
645 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
646 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
647 const uint8_t* zigzag_scan, int bias) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
648 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
649 int i, area; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
650 int run; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
651 int classes[] = {12, 24, 36, 0xffff}; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
652 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
653 run = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
654 bi->mb[0] = blk[0]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
655 bi->cno = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
656 for (area = 0; area < 4; area++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
657 bi->prev_run[area] = run; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
658 bi->bit_size[area] = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
659 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
660 bi->mb[i] = (blk[zigzag_scan[i]] / 16); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
661 while ((bi->mb[i] ^ (bi->mb[i] >> 8)) > classes[bi->cno]) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
662 bi->cno++; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
663 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
664 if (bi->mb[i]) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
665 bi->bit_size[area] += dv_rl2vlc_size(run, bi->mb[i]); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
666 run = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
667 } else |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
668 ++run; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
669 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
670 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
671 bi->bit_size[3] += 4; /* EOB marker */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
672 bi->cno += bias; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
673 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
674 if (bi->cno >= 3) { /* FIXME: we have to recreate bit_size[], prev_run[] */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
675 bi->cno = 3; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
676 for (i=1; i<64; i++) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
677 bi->mb[i] /= 2; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
678 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
679 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
680 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
681 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7)) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
682 static always_inline int dv_guess_dct_mode(DCTELEM *blk) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
683 DCTELEM *s; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
684 int score88 = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
685 int score248 = 0; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
686 int i; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
687 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
688 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
689 s = blk; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
690 for(i=0; i<7; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
691 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
692 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
693 s += 8; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
694 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
695 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
696 s = blk; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
697 for(i=0; i<6; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
698 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) + |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
699 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
700 s += 8; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
701 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
702 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
703 return (score88 - score248 > -10); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
704 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
705 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
706 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
707 { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
708 int size[5]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
709 int i, j, k, a, run; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
710 EncBlockInfo* b; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
711 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
712 do { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
713 b = blks; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
714 for (i=0; i<5; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
715 if (!qnos[i]) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
716 continue; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
717 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
718 qnos[i]--; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
719 size[i] = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
720 for (j=0; j<6; j++, b++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
721 for (a=0; a<4; a++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
722 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
723 b->bit_size[a] = (a==3)?4:0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
724 b->area_q[a]++; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
725 run = b->prev_run[a]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
726 for (k=mb_area_start[a]; k<mb_area_start[a+1]; k++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
727 b->mb[k] /= 2; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
728 if (b->mb[k]) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
729 b->bit_size[a] += dv_rl2vlc_size(run, b->mb[k]); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
730 run = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
731 } else |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
732 ++run; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
733 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
734 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
735 size[i] += b->bit_size[a]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
736 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
737 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
738 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
739 } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) && |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
740 (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4])); |
1567 | 741 } |
742 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
743 /* |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
744 * This is a very rough initial implementaion. The performance is |
1567 | 745 * horrible and the weighting is missing. But it's missing from the |
746 * decoding step also -- so at least we're on the same page with decoder ;-) | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
747 */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
748 static inline void dv_encode_video_segment(DVVideoContext *s, |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
749 uint8_t *dif, |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
750 const uint16_t *mb_pos_ptr) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
751 { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
752 int mb_index, i, j, v; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
753 int mb_x, mb_y, c_offset, linesize; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
754 uint8_t* y_ptr; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
755 uint8_t* data; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
756 uint8_t* ptr; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
757 int do_edge_wrap; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
758 DCTELEM block[64] __align8; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
759 DCTELEM sblock[5*6][64] __align8; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
760 EncBlockInfo enc_blks[5*6]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
761 PutBitContext pbs[5*6]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
762 PutBitContext* pb; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
763 EncBlockInfo* enc_blk; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
764 int vs_bit_size = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
765 int qnos[5]; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
766 |
1567 | 767 enc_blk = &enc_blks[0]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
768 pb = &pbs[0]; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
769 for(mb_index = 0; mb_index < 5; mb_index++) { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
770 v = *mb_pos_ptr++; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
771 mb_x = v & 0xff; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
772 mb_y = v >> 8; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
773 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
774 c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ? |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
775 ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) : |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
776 (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8)); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
777 do_edge_wrap = 0; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
778 qnos[mb_index] = 15; /* No quantization */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
779 ptr = dif + mb_index*80 + 4; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
780 for(j = 0;j < 6; j++) { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
781 if (j < 4) { /* Four Y blocks */ |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
782 /* NOTE: at end of line, the macroblock is handled as 420 */ |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
783 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
784 data = y_ptr + (j * 8); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
785 } else { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
786 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
787 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
788 linesize = s->picture.linesize[0]; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
789 } else { /* Cr and Cb blocks */ |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
790 /* don't ask Fabrice why they inverted Cb and Cr ! */ |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
791 data = s->picture.data[6 - j] + c_offset; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
792 linesize = s->picture.linesize[6 - j]; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
793 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
794 do_edge_wrap = 1; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
795 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
796 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
797 /* Everything is set up -- now just copy data -> DCT block */ |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
798 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */ |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
799 uint8_t* d; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
800 DCTELEM *b = block; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
801 for (i=0;i<8;i++) { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
802 d = data + 8 * linesize; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
803 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3]; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
804 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
805 data += linesize; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
806 b += 8; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
807 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
808 } else { /* Simple copy: 8x8 -> 8x8 */ |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
809 s->get_pixels(block, data, linesize); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
810 } |
1567 | 811 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
812 enc_blk->dct_mode = dv_guess_dct_mode(block); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
813 enc_blk->mb = &sblock[mb_index*6+j][0]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
814 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
815 enc_blk->partial_bit_count = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
816 enc_blk->partial_bit_buffer = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
817 enc_blk->cur_ac = 1; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
818 |
1567 | 819 s->fdct[enc_blk->dct_mode](block); |
820 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
821 dv_set_class_number(block, enc_blk, |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
822 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
823 j/4*(j%2)); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
824 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
825 init_put_bits(pb, ptr, block_sizes[j]/8); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
826 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024) >> 2)); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
827 put_bits(pb, 1, enc_blk->dct_mode); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
828 put_bits(pb, 2, enc_blk->cno); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
829 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
830 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] + |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
831 enc_blk->bit_size[2] + enc_blk->bit_size[3]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
832 ++enc_blk; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
833 ++pb; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
834 ptr += block_sizes[j]/8; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
835 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
836 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
837 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
838 if (vs_total_ac_bits < vs_bit_size) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
839 dv_guess_qnos(&enc_blks[0], &qnos[0]); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
840 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
841 for (i=0; i<5; i++) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
842 dif[i*80 + 3] = qnos[i]; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
843 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
844 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
845 /* First pass over individual cells only */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
846 for (j=0; j<5*6; j++) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
847 dv_encode_ac(&enc_blks[j], &pbs[j], 1); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
848 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
849 /* Second pass over each MB space */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
850 for (j=0; j<5*6; j++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
851 if (enc_blks[j].cur_ac < 65 || enc_blks[j].partial_bit_count) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
852 dv_encode_ac(&enc_blks[j], &pbs[(j/6)*6], 6); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
853 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
854 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
855 /* Third and final pass over the whole vides segment space */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
856 for (j=0; j<5*6; j++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
857 if (enc_blks[j].cur_ac < 65 || enc_blks[j].partial_bit_count) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
858 dv_encode_ac(&enc_blks[j], &pbs[0], 6*5); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
859 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
860 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
861 for (j=0; j<5*6; j++) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
862 flush_put_bits(&pbs[j]); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
863 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
864 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
865 static int dv_decode_mt(AVCodecContext *avctx, void* sl) |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
866 { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
867 DVVideoContext *s = avctx->priv_data; |
1904 | 868 int slice = (size_t)sl; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
869 dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80], |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
870 &s->sys->video_place[slice*5]); |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
871 return 0; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
872 } |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
873 |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
874 static int dv_encode_mt(AVCodecContext *avctx, void* sl) |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
875 { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
876 DVVideoContext *s = avctx->priv_data; |
1904 | 877 int slice = (size_t)sl; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
878 dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80], |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
879 &s->sys->video_place[slice*5]); |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
880 return 0; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
881 } |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
882 |
723 | 883 /* NOTE: exactly one frame must be given (120000 bytes for NTSC, |
884 144000 bytes for PAL) */ | |
885 static int dvvideo_decode_frame(AVCodecContext *avctx, | |
886 void *data, int *data_size, | |
1064 | 887 uint8_t *buf, int buf_size) |
723 | 888 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
889 DVVideoContext *s = avctx->priv_data; |
1726 | 890 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
891 s->sys = dv_frame_profile(buf); |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
892 if (!s->sys || buf_size < s->sys->frame_size) |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
893 return -1; /* NOTE: we only accept several full frames */ |
723 | 894 |
1228 | 895 if(s->picture.data[0]) |
896 avctx->release_buffer(avctx, &s->picture); | |
897 | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
898 s->picture.reference = 0; |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
899 avctx->pix_fmt = s->sys->pix_fmt; |
1507 | 900 avctx->width = s->sys->width; |
901 avctx->height = s->sys->height; | |
903 | 902 if(avctx->get_buffer(avctx, &s->picture) < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1567
diff
changeset
|
903 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
903 | 904 return -1; |
835 | 905 } |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
906 s->picture.interlaced_frame = 1; |
1547 | 907 s->picture.top_field_first = 0; |
835 | 908 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
909 s->buf = buf; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
910 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
911 s->sys->difseg_size * 27); |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
912 |
734
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
913 emms_c(); |
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
914 |
723 | 915 /* return image */ |
925 | 916 *data_size = sizeof(AVFrame); |
917 *(AVFrame*)data= s->picture; | |
903 | 918 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
919 return s->sys->frame_size; |
723 | 920 } |
921 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
922 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
923 void *data) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
924 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
925 DVVideoContext *s = c->priv_data; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
926 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
927 s->sys = dv_codec_profile(c); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
928 if (!s->sys) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
929 return -1; |
2422 | 930 if(buf_size < s->sys->frame_size) |
931 return -1; | |
932 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
933 c->pix_fmt = s->sys->pix_fmt; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
934 s->picture = *((AVFrame *)data); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
935 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
936 s->buf = buf; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
937 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
938 s->sys->difseg_size * 27); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
939 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
940 emms_c(); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
941 return s->sys->frame_size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
942 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
943 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
944 AVCodec dvvideo_encoder = { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
945 "dvvideo", |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
946 CODEC_TYPE_VIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
947 CODEC_ID_DVVIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
948 sizeof(DVVideoContext), |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
949 dvvideo_init, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
950 dvvideo_encode_frame, |
1994 | 951 NULL, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
952 NULL, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
953 CODEC_CAP_DR1, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
954 NULL |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
955 }; |
723 | 956 |
957 AVCodec dvvideo_decoder = { | |
958 "dvvideo", | |
959 CODEC_TYPE_VIDEO, | |
960 CODEC_ID_DVVIDEO, | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
961 sizeof(DVVideoContext), |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
962 dvvideo_init, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
963 NULL, |
1994 | 964 NULL, |
723 | 965 dvvideo_decode_frame, |
835 | 966 CODEC_CAP_DR1, |
723 | 967 NULL |
968 }; |