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