Mercurial > libavcodec.hg
annotate dv.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | d464f498e19f |
children | 85d679e0b591 |
rev | line source |
---|---|
723 | 1 /* |
2 * DV decoder | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8596
diff
changeset
|
3 * Copyright (c) 2002 Fabrice Bellard |
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8596
diff
changeset
|
4 * Copyright (c) 2004 Roman Shaposhnik |
723 | 5 * |
2967 | 6 * DV encoder |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8596
diff
changeset
|
7 * Copyright (c) 2003 Roman Shaposhnik |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
8 * |
3167 | 9 * 50 Mbps (DVCPRO50) support |
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com> | |
11 * | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
12 * 100 Mbps (DVCPRO HD) support |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D) |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
14 * Final code by Roman Shaposhnik |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
15 * |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
16 * 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
|
17 * of DV technical info. |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
18 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
19 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
20 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
21 * FFmpeg is free software; you can redistribute it and/or |
723 | 22 * modify it under the terms of the GNU Lesser General Public |
23 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
24 * version 2.1 of the License, or (at your option) any later version. |
723 | 25 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
26 * FFmpeg is distributed in the hope that it will be useful, |
723 | 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
29 * Lesser General Public License for more details. | |
30 * | |
31 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
32 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3016
diff
changeset
|
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
723 | 34 */ |
1106 | 35 |
36 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8716
diff
changeset
|
37 * @file libavcodec/dv.c |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
38 * DV codec. |
1106 | 39 */ |
3649 | 40 #define ALT_BITSTREAM_READER |
723 | 41 #include "avcodec.h" |
42 #include "dsputil.h" | |
9428 | 43 #include "get_bits.h" |
9411
4cb7c65fc775
Split bitstream.h, put the bitstream writer stuff in the new file
stefano
parents:
9355
diff
changeset
|
44 #include "put_bits.h" |
723 | 45 #include "simple_idct.h" |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
46 #include "dvdata.h" |
723 | 47 |
2847 | 48 //#undef NDEBUG |
49 //#include <assert.h> | |
50 | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
51 typedef struct DVVideoContext { |
8051 | 52 const DVprofile *sys; |
53 AVFrame picture; | |
54 AVCodecContext *avctx; | |
55 uint8_t *buf; | |
2967 | 56 |
8051 | 57 uint8_t dv_zigzag[2][64]; |
2967 | 58 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
59 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); |
1567 | 60 void (*fdct[2])(DCTELEM *block); |
61 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block); | |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
62 me_cmp_func ildct_cmp; |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
63 } DVVideoContext; |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
64 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
65 #define TEX_VLC_BITS 9 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
66 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
67 #if CONFIG_SMALL |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
68 #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
|
69 #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
|
70 #else |
2967 | 71 #define DV_VLC_MAP_RUN_SIZE 64 |
2847 | 72 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
73 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
74 |
723 | 75 /* XXX: also include quantization */ |
4661 | 76 static RL_VLC_ELEM dv_rl_vlc[1184]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
77 /* VLC encoding lookup table */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
78 static struct dv_vlc_pair { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
79 uint32_t vlc; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
80 uint8_t size; |
4666 | 81 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]; |
723 | 82 |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
83 static inline int dv_work_pool_size(const DVprofile *d) |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
84 { |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
85 int size = d->n_difchan*d->difseg_size*27; |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
86 if (DV_PROFILE_IS_1080i50(d)) |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
87 size -= 3*27; |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
88 if (DV_PROFILE_IS_720p50(d)) |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
89 size -= 4*27; |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
90 return size; |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
91 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
92 |
8164 | 93 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot, |
94 uint16_t *tbl) | |
95 { | |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
96 static const uint8_t off[] = { 2, 6, 8, 0, 4 }; |
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
97 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 }; |
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
98 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 }; |
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
99 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 }; |
8164 | 100 |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
101 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40}; |
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
102 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 }; |
8164 | 103 |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
104 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0, |
8164 | 105 0, 1, 2, 2, 1, 0, |
106 0, 1, 2, 2, 1, 0, | |
107 0, 1, 2, 2, 1, 0, | |
108 0, 1, 2}; | |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
109 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, |
8164 | 110 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, |
111 0, 1, 2, 3, 4, 5}; | |
112 | |
8954
409d20e15da8
cosmetics: 'const static' --> 'static const' to avoid warnings of the type
diego
parents:
8738
diff
changeset
|
113 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */ |
8164 | 114 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0}, |
115 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1}, | |
116 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2}, | |
117 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3}, | |
118 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0}, | |
119 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1}, | |
120 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66}, | |
121 {10,64}, {10,65}, {10,66}, {20,64}, {20,65}, | |
122 {20,66}, {30,64}, {30,65}, {30,66}, {40,64}, | |
123 {40,65}, {40,66}, {50,64}, {50,65}, {50,66}, | |
124 {60,64}, {60,65}, {60,66}, {70,64}, {70,65}, | |
125 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}}; | |
126 | |
127 int i, k, m; | |
128 int x, y, blk; | |
129 | |
130 for (m=0; m<5; m++) { | |
131 switch (d->width) { | |
132 case 1440: | |
133 blk = (chan*11+seq)*27+slot; | |
134 | |
135 if (chan == 0 && seq == 11) { | |
136 x = m*27+slot; | |
137 if (x<90) { | |
138 y = 0; | |
139 } else { | |
140 x = (x - 90)*2; | |
141 y = 67; | |
142 } | |
143 } else { | |
144 i = (4*chan + blk + off[m])%11; | |
145 k = (blk/11)%27; | |
146 | |
147 x = shuf1[m] + (chan&1)*9 + k%9; | |
148 y = (i*3+k/9)*2 + (chan>>1) + 1; | |
149 } | |
150 tbl[m] = (x<<1)|(y<<9); | |
151 break; | |
152 case 1280: | |
153 blk = (chan*10+seq)*27+slot; | |
154 | |
155 i = (4*chan + (seq/5) + 2*blk + off[m])%10; | |
156 k = (blk/5)%27; | |
157 | |
158 x = shuf1[m]+(chan&1)*9 + k%9; | |
159 y = (i*3+k/9)*2 + (chan>>1) + 4; | |
160 | |
161 if (x >= 80) { | |
162 x = remap[y][0]+((x-80)<<(y>59)); | |
163 y = remap[y][1]; | |
164 } | |
165 tbl[m] = (x<<1)|(y<<9); | |
166 break; | |
167 case 960: | |
168 blk = (chan*10+seq)*27+slot; | |
169 | |
170 i = (4*chan + (seq/5) + 2*blk + off[m])%10; | |
171 k = (blk/5)%27 + (i&1)*3; | |
172 | |
173 x = shuf2[m] + k%6 + 6*(chan&1); | |
174 y = l_start[i] + k/6 + 45*(chan>>1); | |
175 tbl[m] = (x<<1)|(y<<9); | |
176 break; | |
177 case 720: | |
178 switch (d->pix_fmt) { | |
179 case PIX_FMT_YUV422P: | |
180 x = shuf3[m] + slot/3; | |
181 y = serpent1[slot] + | |
182 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3; | |
183 tbl[m] = (x<<1)|(y<<8); | |
184 break; | |
185 case PIX_FMT_YUV420P: | |
186 x = shuf3[m] + slot/3; | |
187 y = serpent1[slot] + | |
188 ((seq + off[m]) % d->difseg_size)*3; | |
189 tbl[m] = (x<<1)|(y<<9); | |
190 break; | |
191 case PIX_FMT_YUV411P: | |
192 i = (seq + off[m]) % d->difseg_size; | |
193 k = slot + ((m==1||m==2)?3:0); | |
194 | |
195 x = l_start_shuffled[m] + k/6; | |
196 y = serpent2[k] + i*6; | |
197 if (x>21) | |
198 y = y*2 - i*6; | |
199 tbl[m] = (x<<2)|(y<<8); | |
200 break; | |
201 } | |
202 default: | |
203 break; | |
204 } | |
205 } | |
206 } | |
207 | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
208 static int dv_init_dynamic_tables(const DVprofile *d) |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
209 { |
8164 | 210 int j,i,c,s,p; |
8175 | 211 uint32_t *factor1, *factor2; |
212 const int *iweight1, *iweight2; | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
213 |
8173 | 214 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) { |
215 p = i = 0; | |
216 for (c=0; c<d->n_difchan; c++) { | |
217 for (s=0; s<d->difseg_size; s++) { | |
218 p += 6; | |
219 for (j=0; j<27; j++) { | |
220 p += !(j%3); | |
221 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) && | |
222 !(DV_PROFILE_IS_720p50(d) && s > 9)) { | |
223 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]); | |
224 d->work_chunks[i++].buf_offset = p; | |
225 } | |
226 p += 5; | |
227 } | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
228 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
229 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
230 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
231 |
8175 | 232 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) { |
233 factor1 = &d->idct_factor[0]; | |
234 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816]; | |
235 if (d->height == 720) { | |
236 iweight1 = &dv_iweight_720_y[0]; | |
237 iweight2 = &dv_iweight_720_c[0]; | |
238 } else { | |
239 iweight1 = &dv_iweight_1080_y[0]; | |
240 iweight2 = &dv_iweight_1080_c[0]; | |
241 } | |
242 if (DV_PROFILE_IS_HD(d)) { | |
243 for (c = 0; c < 4; c++) { | |
244 for (s = 0; s < 16; s++) { | |
245 for (i = 0; i < 64; i++) { | |
246 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i]; | |
247 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i]; | |
248 } | |
249 } | |
250 } | |
251 } else { | |
252 iweight1 = &dv_iweight_88[0]; | |
253 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) { | |
254 for (s = 0; s < 22; s++) { | |
255 for (i = c = 0; c < 4; c++) { | |
256 for (; i < dv_quant_areas[c]; i++) { | |
257 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1); | |
258 *factor2++ = (*factor1++) << 1; | |
259 } | |
260 } | |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
261 } |
723 | 262 } |
263 } | |
8175 | 264 } |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
265 |
8175 | 266 return 0; |
723 | 267 } |
268 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6450
diff
changeset
|
269 static av_cold int dvvideo_init(AVCodecContext *avctx) |
723 | 270 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
271 DVVideoContext *s = avctx->priv_data; |
1567 | 272 DSPContext dsp; |
8051 | 273 static int done = 0; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
274 int i, j; |
723 | 275 |
276 if (!done) { | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
277 VLC dv_vlc; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
278 uint16_t new_dv_vlc_bits[NB_DV_VLC*2]; |
8051 | 279 uint8_t new_dv_vlc_len[NB_DV_VLC*2]; |
280 uint8_t new_dv_vlc_run[NB_DV_VLC*2]; | |
281 int16_t new_dv_vlc_level[NB_DV_VLC*2]; | |
723 | 282 |
283 done = 1; | |
284 | |
2979 | 285 /* it's faster to include sign bit in a generic VLC parsing scheme */ |
8051 | 286 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) { |
287 new_dv_vlc_bits[j] = dv_vlc_bits[i]; | |
288 new_dv_vlc_len[j] = dv_vlc_len[i]; | |
289 new_dv_vlc_run[j] = dv_vlc_run[i]; | |
2979 | 290 new_dv_vlc_level[j] = dv_vlc_level[i]; |
2967 | 291 |
2979 | 292 if (dv_vlc_level[i]) { |
293 new_dv_vlc_bits[j] <<= 1; | |
294 new_dv_vlc_len[j]++; | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
295 |
2979 | 296 j++; |
8051 | 297 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; |
298 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; | |
299 new_dv_vlc_run[j] = dv_vlc_run[i]; | |
2979 | 300 new_dv_vlc_level[j] = -dv_vlc_level[i]; |
301 } | |
302 } | |
2967 | 303 |
723 | 304 /* NOTE: as a trick, we use the fact the no codes are unused |
305 to accelerate the parsing of partial codes */ | |
2967 | 306 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
|
307 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); |
4661 | 308 assert(dv_vlc.table_size == 1184); |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
309 |
8051 | 310 for (i = 0; i < dv_vlc.table_size; i++){ |
311 int code = dv_vlc.table[i][0]; | |
312 int len = dv_vlc.table[i][1]; | |
723 | 313 int level, run; |
2967 | 314 |
8051 | 315 if (len < 0){ //more bits needed |
316 run = 0; | |
317 level = code; | |
723 | 318 } else { |
8051 | 319 run = new_dv_vlc_run [code] + 1; |
320 level = new_dv_vlc_level[code]; | |
723 | 321 } |
8051 | 322 dv_rl_vlc[i].len = len; |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
323 dv_rl_vlc[i].level = level; |
8051 | 324 dv_rl_vlc[i].run = run; |
723 | 325 } |
2979 | 326 free_vlc(&dv_vlc); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
327 |
2979 | 328 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
|
329 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE) |
2979 | 330 continue; |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
331 #if CONFIG_SMALL |
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
|
332 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) |
2979 | 333 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
|
334 #endif |
2967 | 335 |
2979 | 336 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) |
337 continue; | |
2967 | 338 |
8051 | 339 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = |
340 dv_vlc_bits[i] << (!!dv_vlc_level[i]); | |
341 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = | |
342 dv_vlc_len[i] + (!!dv_vlc_level[i]); | |
2979 | 343 } |
344 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
345 #if CONFIG_SMALL |
2979 | 346 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { |
347 if (dv_vlc_map[i][j].size == 0) { | |
348 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | |
349 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | |
350 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | |
351 dv_vlc_map[0][j].size; | |
352 } | |
353 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
354 #else |
2979 | 355 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { |
356 if (dv_vlc_map[i][j].size == 0) { | |
357 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | |
358 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | |
359 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | |
360 dv_vlc_map[0][j].size; | |
361 } | |
362 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = | |
363 dv_vlc_map[i][j].vlc | 1; | |
364 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = | |
365 dv_vlc_map[i][j].size; | |
366 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
367 #endif |
2979 | 368 } |
723 | 369 } |
725 | 370 |
1567 | 371 /* Generic DSP setup */ |
372 dsputil_init(&dsp, avctx); | |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
373 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp); |
1567 | 374 s->get_pixels = dsp.get_pixels; |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
375 s->ildct_cmp = dsp.ildct_cmp[5]; |
725 | 376 |
1567 | 377 /* 88DCT setup */ |
8051 | 378 s->fdct[0] = dsp.fdct; |
1567 | 379 s->idct_put[0] = dsp.idct_put; |
8051 | 380 for (i = 0; i < 64; i++) |
1567 | 381 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]]; |
725 | 382 |
1567 | 383 /* 248DCT setup */ |
8051 | 384 s->fdct[1] = dsp.fdct248; |
6001 | 385 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP |
8051 | 386 if (avctx->lowres){ |
387 for (i = 0; i < 64; i++){ | |
388 int j = ff_zigzag248_direct[i]; | |
389 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2]; | |
2849 | 390 } |
391 }else | |
392 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); | |
725 | 393 |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
394 avctx->coded_frame = &s->picture; |
8051 | 395 s->avctx = avctx; |
9626
bd3e11b60ccd
Add a chroma_sample_location field to define positioning of chroma samples
conrad
parents:
9428
diff
changeset
|
396 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; |
2967 | 397 |
723 | 398 return 0; |
399 } | |
400 | |
10675
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
401 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx) |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
402 { |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
403 if (!ff_dv_codec_profile(avctx)) { |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
404 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n", |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
405 avctx->width, avctx->height, avcodec_get_pix_fmt_name(avctx->pix_fmt)); |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
406 return -1; |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
407 } |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
408 |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
409 return dvvideo_init(avctx); |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
410 } |
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
411 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
412 // #define VLC_DEBUG |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
413 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__) |
723 | 414 |
725 | 415 typedef struct BlockInfo { |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
416 const uint32_t *factor_table; |
1064 | 417 const uint8_t *scan_table; |
418 uint8_t pos; /* position in block */ | |
7706 | 419 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); |
1064 | 420 uint8_t partial_bit_count; |
421 uint16_t partial_bit_buffer; | |
725 | 422 int shift_offset; |
423 } BlockInfo; | |
723 | 424 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
425 /* 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
|
426 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
|
427 /* see dv_88_areas and dv_248_areas for details */ |
2967 | 428 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; |
723 | 429 |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
430 static inline int put_bits_left(PutBitContext* s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
431 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
432 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
|
433 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
434 |
7980 | 435 /* decode ac coefficients */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
436 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) |
723 | 437 { |
7039 | 438 int last_index = gb->size_in_bits; |
8051 | 439 const uint8_t *scan_table = mb->scan_table; |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
440 const uint32_t *factor_table = mb->factor_table; |
8051 | 441 int pos = mb->pos; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
442 int partial_bit_count = mb->partial_bit_count; |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
443 int level, run, vlc_len, index; |
2967 | 444 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
445 OPEN_READER(re, gb); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
446 UPDATE_CACHE(re, gb); |
2967 | 447 |
723 | 448 /* if we must parse a partial vlc, we do it here */ |
449 if (partial_bit_count > 0) { | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
450 re_cache = ((unsigned)re_cache >> partial_bit_count) | |
8051 | 451 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count)); |
2979 | 452 re_index -= partial_bit_count; |
453 mb->partial_bit_count = 0; | |
723 | 454 } |
455 | |
456 /* get the AC coefficients until last_index is reached */ | |
8051 | 457 for (;;) { |
723 | 458 #ifdef VLC_DEBUG |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
459 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); |
723 | 460 #endif |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
461 /* our own optimized GET_RL_VLC */ |
8051 | 462 index = NEG_USR32(re_cache, TEX_VLC_BITS); |
2979 | 463 vlc_len = dv_rl_vlc[index].len; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
464 if (vlc_len < 0) { |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
465 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
|
466 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
|
467 } |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
468 level = dv_rl_vlc[index].level; |
8051 | 469 run = dv_rl_vlc[index].run; |
2967 | 470 |
2979 | 471 /* gotta check if we're still within gb boundaries */ |
472 if (re_index + vlc_len > last_index) { | |
473 /* should be < 16 bits otherwise a codeword could have been parsed */ | |
474 mb->partial_bit_count = last_index - re_index; | |
475 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count); | |
476 re_index = last_index; | |
477 break; | |
478 } | |
479 re_index += vlc_len; | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
480 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
481 #ifdef VLC_DEBUG |
2979 | 482 printf("run=%d level=%d\n", run, level); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
483 #endif |
2979 | 484 pos += run; |
485 if (pos >= 64) | |
486 break; | |
2967 | 487 |
8051 | 488 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits; |
7536
910087e97750
Coalescing the un-weighting and de-quantization steps for faster
romansh
parents:
7240
diff
changeset
|
489 block[scan_table[pos]] = level; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
490 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
491 UPDATE_CACHE(re, gb); |
723 | 492 } |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
493 CLOSE_READER(re, gb); |
725 | 494 mb->pos = pos; |
723 | 495 } |
496 | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
497 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) |
723 | 498 { |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
499 int bits_left = get_bits_left(gb); |
2847 | 500 while (bits_left >= MIN_CACHE_BITS) { |
501 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); | |
502 bits_left -= MIN_CACHE_BITS; | |
723 | 503 } |
504 if (bits_left > 0) { | |
505 put_bits(pb, bits_left, get_bits(gb, bits_left)); | |
506 } | |
507 } | |
508 | |
8131 | 509 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y) |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
510 { |
8131 | 511 *mb_x = work_chunk->mb_coordinates[m] & 0xff; |
512 *mb_y = work_chunk->mb_coordinates[m] >> 8; | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
513 |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
514 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */ |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
515 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) { |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
516 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */ |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
517 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
518 } |
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
519 |
723 | 520 /* mb_x and mb_y are in units of 8 pixels */ |
8716 | 521 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg) |
723 | 522 { |
8163 | 523 DVVideoContext *s = avctx->priv_data; |
8716 | 524 DVwork_chunk *work_chunk = arg; |
723 | 525 int quant, dc, dct_mode, class1, j; |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
526 int mb_index, mb_x, mb_y, last_index; |
8011 | 527 int y_stride, linesize; |
723 | 528 DCTELEM *block, *block1; |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
529 int c_offset; |
1064 | 530 uint8_t *y_ptr; |
6266 | 531 const uint8_t *buf_ptr; |
723 | 532 PutBitContext pb, vs_pb; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
533 GetBitContext gb; |
7614
1afa1171b7b2
Introducing DV_MAX_BPM macro instead of a hardcoded value for the
romansh
parents:
7538
diff
changeset
|
534 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1; |
11195 | 535 LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]); |
536 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + 4]); /* allow some slack */ | |
537 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5 * 80 + 4]); /* allow some slack */ | |
8051 | 538 const int log2_blocksize = 3-s->avctx->lowres; |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
539 int is_field_mode[5]; |
2967 | 540 |
8051 | 541 assert((((int)mb_bit_buffer) & 7) == 0); |
542 assert((((int)vs_bit_buffer) & 7) == 0); | |
2967 | 543 |
11195 | 544 memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock)); |
723 | 545 |
546 /* pass 1 : read DC and AC coefficients in blocks */ | |
8131 | 547 buf_ptr = &s->buf[work_chunk->buf_offset*80]; |
8051 | 548 block1 = &sblock[0][0]; |
549 mb1 = mb_data; | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
550 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); |
8051 | 551 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) { |
723 | 552 /* skip header */ |
553 quant = buf_ptr[3] & 0x0f; | |
554 buf_ptr += 4; | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
555 init_put_bits(&pb, mb_bit_buffer, 80); |
8051 | 556 mb = mb1; |
723 | 557 block = block1; |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
558 is_field_mode[mb_index] = 0; |
8051 | 559 for (j = 0; j < s->sys->bpm; j++) { |
7616
685ef77c9fe5
Making block size in bits variable and dependent on the DV spec
romansh
parents:
7615
diff
changeset
|
560 last_index = s->sys->block_sizes[j]; |
2979 | 561 init_get_bits(&gb, buf_ptr, last_index); |
2967 | 562 |
723 | 563 /* get the dc */ |
8051 | 564 dc = get_sbits(&gb, 9); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
565 dct_mode = get_bits1(&gb); |
8051 | 566 class1 = get_bits(&gb, 2); |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
567 if (DV_PROFILE_IS_HD(s->sys)) { |
8051 | 568 mb->idct_put = s->idct_put[0]; |
569 mb->scan_table = s->dv_zigzag[0]; | |
8175 | 570 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64]; |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
571 is_field_mode[mb_index] |= !j && dct_mode; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
572 } else { |
8051 | 573 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3]; |
574 mb->scan_table = s->dv_zigzag[dct_mode]; | |
8175 | 575 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 + |
576 (quant + dv_quant_offset[class1])*64]; | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
577 } |
723 | 578 dc = dc << 2; |
579 /* convert to unsigned because 128 is not added in the | |
580 standard IDCT */ | |
581 dc += 1024; | |
582 block[0] = dc; | |
583 buf_ptr += last_index >> 3; | |
8051 | 584 mb->pos = 0; |
725 | 585 mb->partial_bit_count = 0; |
723 | 586 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
587 #ifdef VLC_DEBUG |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
588 printf("MB block: %d, %d ", mb_index, j); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
589 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
590 dv_decode_ac(&gb, mb, block); |
723 | 591 |
592 /* write the remaining bits in a new buffer only if the | |
593 block is finished */ | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
594 if (mb->pos >= 64) |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
595 bit_copy(&pb, &gb); |
2967 | 596 |
723 | 597 block += 64; |
725 | 598 mb++; |
723 | 599 } |
2967 | 600 |
723 | 601 /* pass 2 : we can do it just after */ |
602 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
603 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); |
723 | 604 #endif |
605 block = block1; | |
8051 | 606 mb = mb1; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
607 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); |
2979 | 608 flush_put_bits(&pb); |
8051 | 609 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
610 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
|
611 dv_decode_ac(&gb, mb, block); |
723 | 612 /* 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
|
613 if (mb->pos < 64) |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
614 break; |
723 | 615 } |
616 } | |
617 /* all blocks are finished, so the extra bytes can be used at | |
618 the video segment level */ | |
7615
290fd3ae1219
Making the number of blocks per macroblock dependent on the DV stream
romansh
parents:
7614
diff
changeset
|
619 if (j >= s->sys->bpm) |
2979 | 620 bit_copy(&vs_pb, &gb); |
723 | 621 } |
622 | |
623 /* we need a pass other the whole video segment */ | |
624 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
625 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); |
723 | 626 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
627 block = &sblock[0][0]; |
8051 | 628 mb = mb_data; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
629 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
|
630 flush_put_bits(&vs_pb); |
8051 | 631 for (mb_index = 0; mb_index < 5; mb_index++) { |
632 for (j = 0; j < s->sys->bpm; j++) { | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
633 if (mb->pos < 64) { |
723 | 634 #ifdef VLC_DEBUG |
635 printf("start %d:%d\n", mb_index, j); | |
636 #endif | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
637 dv_decode_ac(&gb, mb, block); |
723 | 638 } |
2979 | 639 if (mb->pos >= 64 && mb->pos < 127) |
10321 | 640 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); |
723 | 641 block += 64; |
725 | 642 mb++; |
723 | 643 } |
644 } | |
2967 | 645 |
723 | 646 /* compute idct and place blocks */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
647 block = &sblock[0][0]; |
8051 | 648 mb = mb_data; |
649 for (mb_index = 0; mb_index < 5; mb_index++) { | |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
650 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
651 |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
652 /* idct_put'ting luminance */ |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
653 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
654 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
655 (s->sys->height >= 720 && mb_y != 134)) { |
8051 | 656 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize)); |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
657 } else { |
8051 | 658 y_stride = (2 << log2_blocksize); |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
659 } |
8051 | 660 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize); |
661 linesize = s->picture.linesize[0] << is_field_mode[mb_index]; | |
662 mb[0] .idct_put(y_ptr , linesize, block + 0*64); | |
8011 | 663 if (s->sys->video_stype == 4) { /* SD 422 */ |
8051 | 664 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64); |
8011 | 665 } else { |
8051 | 666 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64); |
667 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64); | |
668 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64); | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
669 } |
8011 | 670 mb += 4; |
671 block += 4*64; | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
672 |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
673 /* idct_put'ting chrominance */ |
8051 | 674 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + |
675 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize); | |
676 for (j = 2; j; j--) { | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
677 uint8_t *c_ptr = s->picture.data[j] + c_offset; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
678 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
679 uint64_t aligned_pixels[64/8]; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
680 uint8_t *pixels = (uint8_t*)aligned_pixels; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
681 uint8_t *c_ptr1, *ptr1; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
682 int x, y; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
683 mb->idct_put(pixels, 8, block); |
8051 | 684 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) { |
685 ptr1 = pixels + (1 << (log2_blocksize - 1)); | |
686 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize); | |
687 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) { | |
688 c_ptr[x] = pixels[x]; | |
689 c_ptr1[x] = ptr1[x]; | |
7715
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
690 } |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
691 } |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
692 block += 64; mb++; |
e8f71784062e
Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as
romansh
parents:
7708
diff
changeset
|
693 } else { |
8051 | 694 y_stride = (mb_y == 134) ? (1 << log2_blocksize) : |
695 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize); | |
696 linesize = s->picture.linesize[j] << is_field_mode[mb_index]; | |
697 (mb++)-> idct_put(c_ptr , linesize, block); block += 64; | |
8011 | 698 if (s->sys->bpm == 8) { |
8051 | 699 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64; |
8011 | 700 } |
723 | 701 } |
702 } | |
703 } | |
8163 | 704 return 0; |
723 | 705 } |
706 | |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
707 #if CONFIG_SMALL |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
708 /* Converts run and level (where level != 0) pair into vlc, returning bit size */ |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
709 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
710 { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
711 int size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
712 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
|
713 *vlc = dv_vlc_map[run][level].vlc | sign; |
2979 | 714 size = dv_vlc_map[run][level].size; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
715 } |
2967 | 716 else { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
717 if (level < DV_VLC_MAP_LEV_SIZE) { |
2979 | 718 *vlc = dv_vlc_map[0][level].vlc | sign; |
719 size = dv_vlc_map[0][level].size; | |
720 } else { | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
721 *vlc = 0xfe00 | (level << 1) | sign; |
2979 | 722 size = 16; |
723 } | |
724 if (run) { | |
725 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : | |
726 (0x1f80 | (run - 1))) << size; | |
8051 | 727 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; |
2979 | 728 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
729 } |
2967 | 730 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
731 return size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
732 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
733 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
734 static av_always_inline int dv_rl2vlc_size(int run, int level) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
735 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
736 int size; |
2967 | 737 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
738 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
2979 | 739 size = dv_vlc_map[run][level].size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
740 } |
2967 | 741 else { |
2979 | 742 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; |
743 if (run) { | |
744 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; | |
745 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
746 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
747 return size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
748 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
749 #else |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
750 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
751 { |
2847 | 752 *vlc = dv_vlc_map[run][l].vlc | sign; |
753 return dv_vlc_map[run][l].size; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
754 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
755 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
756 static av_always_inline int dv_rl2vlc_size(int run, int l) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
757 { |
2847 | 758 return dv_vlc_map[run][l].size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
759 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
760 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
761 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
762 typedef struct EncBlockInfo { |
8051 | 763 int area_q[4]; |
764 int bit_size[4]; | |
765 int prev[5]; | |
766 int cur_ac; | |
767 int cno; | |
768 int dct_mode; | |
769 DCTELEM mb[64]; | |
770 uint8_t next[64]; | |
771 uint8_t sign[64]; | |
772 uint8_t partial_bit_count; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
773 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
|
774 } EncBlockInfo; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
775 |
8051 | 776 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, |
777 PutBitContext* pb_pool, | |
778 PutBitContext* pb_end) | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
779 { |
8051 | 780 int prev, bits_left; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
781 PutBitContext* pb = pb_pool; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
782 int size = bi->partial_bit_count; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
783 uint32_t vlc = bi->partial_bit_buffer; |
2847 | 784 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
785 bi->partial_bit_count = bi->partial_bit_buffer = 0; |
8051 | 786 for (;;){ |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
787 /* Find suitable storage space */ |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1726
diff
changeset
|
788 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
|
789 if (bits_left) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
790 size -= bits_left; |
2979 | 791 put_bits(pb, bits_left, vlc >> size); |
8051 | 792 vlc = vlc & ((1 << size) - 1); |
2979 | 793 } |
794 if (pb + 1 >= pb_end) { | |
8051 | 795 bi->partial_bit_count = size; |
2979 | 796 bi->partial_bit_buffer = vlc; |
797 return pb; | |
798 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
799 } |
2967 | 800 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
801 /* Store VLC */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
802 put_bits(pb, size, vlc); |
2967 | 803 |
8051 | 804 if (bi->cur_ac >= 64) |
2847 | 805 break; |
2967 | 806 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
807 /* Construct the next VLC */ |
8051 | 808 prev = bi->cur_ac; |
2847 | 809 bi->cur_ac = bi->next[prev]; |
8051 | 810 if (bi->cur_ac < 64){ |
2847 | 811 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); |
812 } else { | |
813 size = 4; vlc = 6; /* End Of Block stamp */ | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
814 } |
2847 | 815 } |
816 return pb; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
817 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
818 |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
819 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) { |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
820 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) { |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
821 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400; |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
822 if (ps > 0) { |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
823 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) + |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
824 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4); |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
825 return (ps > is); |
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
826 } |
8990 | 827 } |
828 | |
829 return 0; | |
8703 | 830 } |
831 | |
8705 | 832 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
833 { |
8705 | 834 const int *weight; |
835 const uint8_t* zigzag_scan; | |
11195 | 836 LOCAL_ALIGNED_16(DCTELEM, blk, [64]); |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
837 int i, area; |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
838 /* We offer two different methods for class number assignment: the |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
839 method suggested in SMPTE 314M Table 22, and an improved |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
840 method. The SMPTE method is very conservative; it assigns class |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
841 3 (i.e. severe quantization) to any block where the largest AC |
7980 | 842 component is greater than 36. FFmpeg's DV encoder tracks AC bit |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
843 consumption precisely, so there is no need to bias most blocks |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
844 towards strongly lossy compression. Instead, we assign class 2 |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
845 to most blocks, and use class 3 only when strictly necessary |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
846 (for blocks whose largest AC component exceeds 255). */ |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
847 |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
848 #if 0 /* SMPTE spec method */ |
2847 | 849 static const int classes[] = {12, 24, 36, 0xffff}; |
7980 | 850 #else /* improved FFmpeg method */ |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
851 static const int classes[] = {-1, -1, 255, 0xffff}; |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
852 #endif |
8051 | 853 int max = classes[0]; |
854 int prev = 0; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
855 |
8705 | 856 assert((((int)blk) & 15) == 0); |
857 | |
858 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0; | |
859 bi->partial_bit_count = 0; | |
860 bi->partial_bit_buffer = 0; | |
861 bi->cur_ac = 0; | |
862 if (data) { | |
8979
5337b260a70d
transitioning dv_guess_dct_mode to dsputil cmp function
romansh
parents:
8954
diff
changeset
|
863 bi->dct_mode = dv_guess_dct_mode(s, data, linesize); |
8705 | 864 s->get_pixels(blk, data, linesize); |
865 s->fdct[bi->dct_mode](blk); | |
866 } else { | |
867 /* We rely on the fact that encoding all zeros leads to an immediate EOB, | |
868 which is precisely what the spec calls for in the "dummy" blocks. */ | |
11195 | 869 memset(blk, 0, 64*sizeof(*blk)); |
8705 | 870 bi->dct_mode = 0; |
871 } | |
2967 | 872 bi->mb[0] = blk[0]; |
873 | |
8705 | 874 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct; |
875 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88; | |
876 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
877 for (area = 0; area < 4; area++) { |
8051 | 878 bi->prev[area] = prev; |
2847 | 879 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) |
8051 | 880 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) { |
2847 | 881 int level = blk[zigzag_scan[i]]; |
2967 | 882 |
8051 | 883 if (level + 15 > 30U) { |
884 bi->sign[i] = (level >> 31) & 1; | |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
885 /* weigh it and and shift down into range, adding for rounding */ |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
886 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
887 AND the 2x doubling of the weights */ |
8051 | 888 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4); |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
889 bi->mb[i] = level; |
8051 | 890 if (level > max) |
891 max = level; | |
2847 | 892 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); |
893 bi->next[prev]= i; | |
8051 | 894 prev = i; |
2847 | 895 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
896 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
897 } |
2847 | 898 bi->next[prev]= i; |
8051 | 899 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++); |
2847 | 900 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
901 bi->cno += bias; |
2967 | 902 |
2847 | 903 if (bi->cno >= 3) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
904 bi->cno = 3; |
8051 | 905 prev = 0; |
906 i = bi->next[prev]; | |
2847 | 907 for (area = 0; area < 4; area++) { |
8051 | 908 bi->prev[area] = prev; |
2847 | 909 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) |
8051 | 910 for (; i < mb_area_start[area+1]; i = bi->next[i]) { |
911 bi->mb[i] >>= 1; | |
2967 | 912 |
2847 | 913 if (bi->mb[i]) { |
914 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); | |
915 bi->next[prev]= i; | |
8051 | 916 prev = i; |
2847 | 917 } |
918 } | |
919 } | |
920 bi->next[prev]= i; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
921 } |
8705 | 922 |
923 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3]; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
924 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
925 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
926 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
|
927 { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
928 int size[5]; |
3140 | 929 int i, j, k, a, prev, a2; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
930 EncBlockInfo* b; |
2847 | 931 |
8051 | 932 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
933 do { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
934 b = blks; |
8051 | 935 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
|
936 if (!qnos[i]) |
2979 | 937 continue; |
2967 | 938 |
2979 | 939 qnos[i]--; |
940 size[i] = 0; | |
8051 | 941 for (j = 0; j < 6; j++, b++) { |
942 for (a = 0; a < 4; a++) { | |
2979 | 943 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { |
944 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) | |
945 b->area_q[a]++; | |
8051 | 946 prev = b->prev[a]; |
3147 | 947 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); |
8051 | 948 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) { |
2979 | 949 b->mb[k] >>= 1; |
950 if (b->mb[k]) { | |
2847 | 951 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); |
8051 | 952 prev = k; |
2847 | 953 } else { |
8051 | 954 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){ |
955 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++) | |
3146
dcae1bde37ac
size[0-3] are not initialized (and can get random negative trash
michael
parents:
3143
diff
changeset
|
956 b->prev[a2] = prev; |
8051 | 957 assert(a2 < 4); |
3140 | 958 assert(b->mb[b->next[k]]); |
959 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) | |
960 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); | |
8051 | 961 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k)); |
3147 | 962 b->prev[a2] = prev; |
3140 | 963 } |
2847 | 964 b->next[prev] = b->next[k]; |
965 } | |
2979 | 966 } |
2847 | 967 b->prev[a+1]= prev; |
2979 | 968 } |
969 size[i] += b->bit_size[a]; | |
970 } | |
971 } | |
8051 | 972 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) |
3142 | 973 return; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
974 } |
3140 | 975 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); |
976 | |
977 | |
8051 | 978 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){ |
3140 | 979 b = blks; |
8051 | 980 size[0] = 5 * 6 * 4; //EOB |
981 for (j = 0; j < 6 *5; j++, b++) { | |
982 prev = b->prev[0]; | |
983 for (k = b->next[prev]; k < 64; k = b->next[k]) { | |
984 if (b->mb[k] < a && b->mb[k] > -a){ | |
3140 | 985 b->next[prev] = b->next[k]; |
986 }else{ | |
987 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); | |
8051 | 988 prev = k; |
3140 | 989 } |
990 } | |
991 } | |
992 } | |
1567 | 993 } |
994 | |
8716 | 995 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
996 { |
8163 | 997 DVVideoContext *s = avctx->priv_data; |
8716 | 998 DVwork_chunk *work_chunk = arg; |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
999 int mb_index, i, j; |
8709 | 1000 int mb_x, mb_y, c_offset, linesize, y_stride; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1001 uint8_t* y_ptr; |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
1002 uint8_t* dif; |
8705 | 1003 uint8_t scratch[64]; |
8702 | 1004 EncBlockInfo enc_blks[5*DV_MAX_BPM]; |
1005 PutBitContext pbs[5*DV_MAX_BPM]; | |
2967 | 1006 PutBitContext* pb; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1007 EncBlockInfo* enc_blk; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1008 int vs_bit_size = 0; |
8708 | 1009 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */ |
8707 | 1010 int* qnosp = &qnos[0]; |
2967 | 1011 |
8131 | 1012 dif = &s->buf[work_chunk->buf_offset*80]; |
1567 | 1013 enc_blk = &enc_blks[0]; |
8051 | 1014 for (mb_index = 0; mb_index < 5; mb_index++) { |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
1015 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); |
8709 | 1016 |
1017 /* initializing luminance blocks */ | |
1018 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || | |
1019 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || | |
1020 (s->sys->height >= 720 && mb_y != 134)) { | |
1021 y_stride = s->picture.linesize[0] << 3; | |
1022 } else { | |
1023 y_stride = 16; | |
1024 } | |
8051 | 1025 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3); |
8709 | 1026 linesize = s->picture.linesize[0]; |
1027 | |
1028 if (s->sys->video_stype == 4) { /* SD 422 */ | |
1029 vs_bit_size += | |
1030 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + | |
1031 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) + | |
1032 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) + | |
1033 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0); | |
1034 } else { | |
1035 vs_bit_size += | |
1036 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + | |
1037 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) + | |
1038 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) + | |
1039 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0); | |
1040 } | |
1041 enc_blk += 4; | |
1042 | |
1043 /* initializing chrominance blocks */ | |
8051 | 1044 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + |
1045 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3); | |
8709 | 1046 for (j = 2; j; j--) { |
1047 uint8_t *c_ptr = s->picture.data[j] + c_offset; | |
1048 linesize = s->picture.linesize[j]; | |
1049 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3); | |
8710 | 1050 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
1051 uint8_t* d; | |
1052 uint8_t* b = scratch; | |
1053 for (i = 0; i < 8; i++) { | |
1054 d = c_ptr + (linesize << 3); | |
1055 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3]; | |
1056 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; | |
1057 c_ptr += linesize; | |
1058 b += 8; | |
1059 } | |
1060 c_ptr = scratch; | |
1061 linesize = 8; | |
1062 } | |
8709 | 1063 |
1064 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1); | |
1065 if (s->sys->bpm == 8) { | |
1066 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1); | |
2979 | 1067 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1068 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1069 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1070 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1071 if (vs_total_ac_bits < vs_bit_size) |
8707 | 1072 dv_guess_qnos(&enc_blks[0], qnosp); |
1073 | |
1074 /* DIF encoding process */ | |
1075 for (j=0; j<5*s->sys->bpm;) { | |
1076 int start_mb = j; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1077 |
8707 | 1078 dif[3] = *qnosp++; |
1079 dif += 4; | |
1080 | |
1081 /* First pass over individual cells only */ | |
1082 for (i=0; i<s->sys->bpm; i++, j++) { | |
1083 int sz = s->sys->block_sizes[i]>>3; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1084 |
8707 | 1085 init_put_bits(&pbs[j], dif, sz); |
9741
e52891e48ceb
remove cast and use put_sbits, fix assertion in put_bits
bcoudurier
parents:
9626
diff
changeset
|
1086 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2); |
8707 | 1087 put_bits(&pbs[j], 1, enc_blks[j].dct_mode); |
1088 put_bits(&pbs[j], 2, enc_blks[j].cno); | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1089 |
8707 | 1090 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); |
1091 dif += sz; | |
1092 } | |
1093 | |
1094 /* Second pass over each MB space */ | |
1095 pb = &pbs[start_mb]; | |
8702 | 1096 for (i=0; i<s->sys->bpm; i++) { |
8707 | 1097 if (enc_blks[start_mb+i].partial_bit_count) |
1098 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]); | |
2847 | 1099 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1100 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1101 |
8050 | 1102 /* Third and final pass over the whole video segment space */ |
8051 | 1103 pb = &pbs[0]; |
8702 | 1104 for (j=0; j<5*s->sys->bpm; j++) { |
2847 | 1105 if (enc_blks[j].partial_bit_count) |
8702 | 1106 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]); |
3139
e58fb7ffbb4f
print a big warning if we mess up and run out of space ...
michael
parents:
3089
diff
changeset
|
1107 if (enc_blks[j].partial_bit_count) |
10321 | 1108 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n"); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1109 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1110 |
10320
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1111 for (j=0; j<5*s->sys->bpm; j++) { |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1112 int pos; |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1113 int size = pbs[j].size_in_bits >> 3; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
1114 flush_put_bits(&pbs[j]); |
10320
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1115 pos = put_bits_count(&pbs[j]) >> 3; |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1116 if (pos > size) { |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1117 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n"); |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1118 return -1; |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1119 } |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1120 memset(pbs[j].buf + pos, 0xff, size - pos); |
44f31c1c9acc
Make sure that dv encoder initializes all encoded packet data.
reimar
parents:
10146
diff
changeset
|
1121 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1122 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1123 return 0; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1124 } |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1125 |
8590 | 1126 #if CONFIG_DVVIDEO_DECODER |
723 | 1127 /* NOTE: exactly one frame must be given (120000 bytes for NTSC, |
3167 | 1128 144000 bytes for PAL - or twice those for 50Mbps) */ |
2967 | 1129 static int dvvideo_decode_frame(AVCodecContext *avctx, |
723 | 1130 void *data, int *data_size, |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8990
diff
changeset
|
1131 AVPacket *avpkt) |
723 | 1132 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8990
diff
changeset
|
1133 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8990
diff
changeset
|
1134 int buf_size = avpkt->size; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1135 DVVideoContext *s = avctx->priv_data; |
2967 | 1136 |
10409
3c13cad19e29
Split parts of dvdata.h into dvdata.c, this ensures that things like
reimar
parents:
10321
diff
changeset
|
1137 s->sys = ff_dv_frame_profile(s->sys, buf, buf_size); |
9856
ff2358195bc7
print error when dv frame profile cannot be found
bcoudurier
parents:
9855
diff
changeset
|
1138 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) { |
ff2358195bc7
print error when dv frame profile cannot be found
bcoudurier
parents:
9855
diff
changeset
|
1139 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n"); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1140 return -1; /* NOTE: we only accept several full frames */ |
9856
ff2358195bc7
print error when dv frame profile cannot be found
bcoudurier
parents:
9855
diff
changeset
|
1141 } |
723 | 1142 |
8051 | 1143 if (s->picture.data[0]) |
1228 | 1144 avctx->release_buffer(avctx, &s->picture); |
2967 | 1145 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1146 s->picture.reference = 0; |
2822
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1147 s->picture.key_frame = 1; |
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1148 s->picture.pict_type = FF_I_TYPE; |
8051 | 1149 avctx->pix_fmt = s->sys->pix_fmt; |
8014
07d8986fbea7
replacing frame_rate and frame_rate_base with an AVRational time_base
romansh
parents:
8011
diff
changeset
|
1150 avctx->time_base = s->sys->time_base; |
2849 | 1151 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height); |
8051 | 1152 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
|
1153 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
903 | 1154 return -1; |
835 | 1155 } |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
1156 s->picture.interlaced_frame = 1; |
8051 | 1157 s->picture.top_field_first = 0; |
835 | 1158 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1159 s->buf = buf; |
8163 | 1160 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL, |
8131 | 1161 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); |
2967 | 1162 |
734
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
1163 emms_c(); |
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
1164 |
723 | 1165 /* return image */ |
925 | 1166 *data_size = sizeof(AVFrame); |
8051 | 1167 *(AVFrame*)data = s->picture; |
2967 | 1168 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1169 return s->sys->frame_size; |
723 | 1170 } |
7776
dbcdd0165e55
Replace generic CONFIG_DECODERS preprocessor conditionals by more specific
diego
parents:
7715
diff
changeset
|
1171 #endif /* CONFIG_DVVIDEO_DECODER */ |
723 | 1172 |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1173 |
8051 | 1174 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, |
1175 uint8_t* buf) | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1176 { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1177 /* |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1178 * Here's what SMPTE314M says about these two: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1179 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1180 * as track application IDs (APTn = 001, AP1n = |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1181 * 001, AP2n = 001, AP3n = 001), if the source signal |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1182 * comes from a digital VCR. If the signal source is |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1183 * unknown, all bits for these data shall be set to 1. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1184 * (page 12) STYPE: STYPE defines a signal type of video signal |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1185 * 00000b = 4:1:1 compression |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1186 * 00100b = 4:2:2 compression |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1187 * XXXXXX = Reserved |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1188 * Now, I've got two problems with these statements: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1189 * 1. it looks like APT == 111b should be a safe bet, but it isn't. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1190 * It seems that for PAL as defined in IEC 61834 we have to set |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1191 * APT to 000 and for SMPTE314M to 001. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1192 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1193 * compression scheme (if any). |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1194 */ |
8051 | 1195 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1); |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1196 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1197 uint8_t aspect = 0; |
8714
ba1e52769fc5
assume widescreen when ratio also > 17, patch by Ben Hutchings, ben at decadent dot org dot uk
bcoudurier
parents:
8710
diff
changeset
|
1198 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1199 aspect = 0x02; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1200 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1201 buf[0] = (uint8_t)pack_id; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1202 switch (pack_id) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1203 case dv_header525: /* I can't imagine why these two weren't defined as real */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1204 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */ |
8051 | 1205 buf[1] = 0xf8 | /* reserved -- always 1 */ |
1206 (apt & 0x07); /* APT: Track application ID */ | |
1207 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */ | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1208 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1209 (apt & 0x07); /* AP1: Audio application ID */ |
8051 | 1210 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1211 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1212 (apt & 0x07); /* AP2: Video application ID */ |
8051 | 1213 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1214 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1215 (apt & 0x07); /* AP3: Subcode application ID */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1216 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1217 case dv_video_source: |
8051 | 1218 buf[1] = 0xff; /* reserved -- always 1 */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1219 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1220 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */ |
8050 | 1221 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */ |
8051 | 1222 0xf; /* reserved -- always 1 */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1223 buf[3] = (3 << 6) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1224 (c->sys->dsf << 5) | /* system: 60fields/50fields */ |
8738 | 1225 c->sys->video_stype; /* signal type video compression */ |
8051 | 1226 buf[4] = 0xff; /* VISC: 0xff -- no information */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1227 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1228 case dv_video_control: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1229 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */ |
8051 | 1230 0x3f; /* reserved -- always 1 */ |
1231 buf[2] = 0xc8 | /* reserved -- always b11001xxx */ | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1232 aspect; |
8050 | 1233 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */ |
1234 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */ | |
1235 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */ | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1236 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */ |
8051 | 1237 0xc; /* reserved -- always b1100 */ |
1238 buf[4] = 0xff; /* reserved -- always 1 */ | |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1239 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1240 default: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1241 buf[1] = buf[2] = buf[3] = buf[4] = 0xff; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1242 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1243 return 5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1244 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1245 |
8590 | 1246 #if CONFIG_DVVIDEO_ENCODER |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1247 static void dv_format_frame(DVVideoContext* c, uint8_t* buf) |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1248 { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1249 int chan, i, j, k; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1250 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1251 for (chan = 0; chan < c->sys->n_difchan; chan++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1252 for (i = 0; i < c->sys->difseg_size; i++) { |
8050 | 1253 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */ |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1254 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1255 /* DV header: 1DIF */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1256 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1257 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1258 buf += 72; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1259 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1260 /* DV subcode: 2DIFs */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1261 for (j = 0; j < 2; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1262 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1263 for (k = 0; k < 6; k++) |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1264 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1265 buf += 29; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1266 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1267 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1268 /* DV VAUX: 3DIFS */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1269 for (j = 0; j < 3; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1270 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1271 buf += dv_write_pack(dv_video_source, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1272 buf += dv_write_pack(dv_video_control, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1273 buf += 7*5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1274 buf += dv_write_pack(dv_video_source, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1275 buf += dv_write_pack(dv_video_control, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1276 buf += 4*5 + 2; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1277 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1278 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1279 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1280 for (j = 0; j < 135; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1281 if (j%15 == 0) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1282 memset(buf, 0xff, 80); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1283 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1284 buf += 77; /* audio control & shuffled PCM audio */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1285 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1286 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf); |
7980 | 1287 buf += 77; /* 1 video macroblock: 1 bytes control |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1288 4 * 14 bytes Y 8x8 data |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1289 10 bytes Cr 8x8 data |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1290 10 bytes Cb 8x8 data */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1291 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1292 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1293 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1294 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1295 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1296 |
2967 | 1297 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1298 void *data) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1299 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1300 DVVideoContext *s = c->priv_data; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1301 |
10409
3c13cad19e29
Split parts of dvdata.h into dvdata.c, this ensures that things like
reimar
parents:
10321
diff
changeset
|
1302 s->sys = ff_dv_codec_profile(c); |
8118
890df98a7848
implementing more efficient (and direct) allocation of work for DV codec workers
romansh
parents:
8088
diff
changeset
|
1303 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) |
2422 | 1304 return -1; |
1305 | |
8051 | 1306 c->pix_fmt = s->sys->pix_fmt; |
1307 s->picture = *((AVFrame *)data); | |
2822
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1308 s->picture.key_frame = 1; |
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1309 s->picture.pict_type = FF_I_TYPE; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1310 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1311 s->buf = buf; |
8163 | 1312 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL, |
8131 | 1313 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1314 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1315 emms_c(); |
3167 | 1316 |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1317 dv_format_frame(s, buf); |
3167 | 1318 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1319 return s->sys->frame_size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1320 } |
3806 | 1321 #endif |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1322 |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1323 static int dvvideo_close(AVCodecContext *c) |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1324 { |
4352
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1325 DVVideoContext *s = c->priv_data; |
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1326 |
8051 | 1327 if (s->picture.data[0]) |
4352
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1328 c->release_buffer(c, &s->picture); |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1329 |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1330 return 0; |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1331 } |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1332 |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1333 |
8590 | 1334 #if CONFIG_DVVIDEO_ENCODER |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1335 AVCodec dvvideo_encoder = { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1336 "dvvideo", |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1337 CODEC_TYPE_VIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1338 CODEC_ID_DVVIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1339 sizeof(DVVideoContext), |
10675
03d02e21b432
Fail earlier for unsupported resolutions or pixel formats when encoding
cehoyos
parents:
10504
diff
changeset
|
1340 dvvideo_init_encoder, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1341 dvvideo_encode_frame, |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
10093
diff
changeset
|
1342 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE}, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7039
diff
changeset
|
1343 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1344 }; |
2661
b2846918585c
a few #ifdef CONFIG_X_ENCODER, patch by (Roine Gustafsson <roine users.sourceforge net]
michael
parents:
2614
diff
changeset
|
1345 #endif // CONFIG_DVVIDEO_ENCODER |
723 | 1346 |
8590 | 1347 #if CONFIG_DVVIDEO_DECODER |
723 | 1348 AVCodec dvvideo_decoder = { |
1349 "dvvideo", | |
1350 CODEC_TYPE_VIDEO, | |
1351 CODEC_ID_DVVIDEO, | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1352 sizeof(DVVideoContext), |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1353 dvvideo_init, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1354 NULL, |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1355 dvvideo_close, |
723 | 1356 dvvideo_decode_frame, |
835 | 1357 CODEC_CAP_DR1, |
6717 | 1358 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
7039
diff
changeset
|
1359 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), |
723 | 1360 }; |
3777 | 1361 #endif |