e3b1064a9574df0082eac3582fdfa22ff0f76ccb
[libav.git] / libavcodec / dv.c
1 /*
2 * DV decoder
3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
5 *
6 * DV encoder
7 * Copyright (c) 2003 Roman Shaposhnik
8 *
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
11 *
12 * 100 Mbps (DVCPRO HD) support
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14 * Final code by Roman Shaposhnik
15 *
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17 * of DV technical info.
18 *
19 * This file is part of FFmpeg.
20 *
21 * FFmpeg is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU Lesser General Public
23 * License as published by the Free Software Foundation; either
24 * version 2.1 of the License, or (at your option) any later version.
25 *
26 * FFmpeg is distributed in the hope that it will be useful,
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
32 * License along with FFmpeg; if not, write to the Free Software
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34 */
35
36 /**
37 * @file libavcodec/dv.c
38 * DV codec.
39 */
40 #define ALT_BITSTREAM_READER
41 #include "avcodec.h"
42 #include "dsputil.h"
43 #include "get_bits.h"
44 #include "put_bits.h"
45 #include "simple_idct.h"
46 #include "dvdata.h"
47 #include "dv_tablegen.h"
48
49 //#undef NDEBUG
50 //#include <assert.h>
51
52 typedef struct DVVideoContext {
53 const DVprofile *sys;
54 AVFrame picture;
55 AVCodecContext *avctx;
56 uint8_t *buf;
57
58 uint8_t dv_zigzag[2][64];
59
60 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
61 void (*fdct[2])(DCTELEM *block);
62 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
63 me_cmp_func ildct_cmp;
64 } DVVideoContext;
65
66 #define TEX_VLC_BITS 9
67
68 /* XXX: also include quantization */
69 static RL_VLC_ELEM dv_rl_vlc[1184];
70
71 static inline int dv_work_pool_size(const DVprofile *d)
72 {
73 int size = d->n_difchan*d->difseg_size*27;
74 if (DV_PROFILE_IS_1080i50(d))
75 size -= 3*27;
76 if (DV_PROFILE_IS_720p50(d))
77 size -= 4*27;
78 return size;
79 }
80
81 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
82 uint16_t *tbl)
83 {
84 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
85 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
86 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
87 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
88
89 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
90 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
91
92 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
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};
97 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
98 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
99 0, 1, 2, 3, 4, 5};
100
101 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
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
196 static int dv_init_dynamic_tables(const DVprofile *d)
197 {
198 int j,i,c,s,p;
199 uint32_t *factor1, *factor2;
200 const int *iweight1, *iweight2;
201
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 }
216 }
217 }
218 }
219
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];
229 }
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;
247 }
248 }
249 }
250 }
251 }
252 }
253
254 return 0;
255 }
256
257 static av_cold int dvvideo_init(AVCodecContext *avctx)
258 {
259 DVVideoContext *s = avctx->priv_data;
260 DSPContext dsp;
261 static int done = 0;
262 int i, j;
263
264 if (!done) {
265 VLC dv_vlc;
266 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
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];
270
271 done = 1;
272
273 /* it's faster to include sign bit in a generic VLC parsing scheme */
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];
278 new_dv_vlc_level[j] = dv_vlc_level[i];
279
280 if (dv_vlc_level[i]) {
281 new_dv_vlc_bits[j] <<= 1;
282 new_dv_vlc_len[j]++;
283
284 j++;
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];
288 new_dv_vlc_level[j] = -dv_vlc_level[i];
289 }
290 }
291
292 /* NOTE: as a trick, we use the fact the no codes are unused
293 to accelerate the parsing of partial codes */
294 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
295 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
296 assert(dv_vlc.table_size == 1184);
297
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];
301 int level, run;
302
303 if (len < 0){ //more bits needed
304 run = 0;
305 level = code;
306 } else {
307 run = new_dv_vlc_run [code] + 1;
308 level = new_dv_vlc_level[code];
309 }
310 dv_rl_vlc[i].len = len;
311 dv_rl_vlc[i].level = level;
312 dv_rl_vlc[i].run = run;
313 }
314 free_vlc(&dv_vlc);
315
316 dv_vlc_map_tableinit();
317 }
318
319 /* Generic DSP setup */
320 dsputil_init(&dsp, avctx);
321 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
322 s->get_pixels = dsp.get_pixels;
323 s->ildct_cmp = dsp.ildct_cmp[5];
324
325 /* 88DCT setup */
326 s->fdct[0] = dsp.fdct;
327 s->idct_put[0] = dsp.idct_put;
328 for (i = 0; i < 64; i++)
329 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
330
331 /* 248DCT setup */
332 s->fdct[1] = dsp.fdct248;
333 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
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];
338 }
339 }else
340 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
341
342 avctx->coded_frame = &s->picture;
343 s->avctx = avctx;
344 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
345
346 return 0;
347 }
348
349 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
350 {
351 if (!ff_dv_codec_profile(avctx)) {
352 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
353 avctx->width, avctx->height, avcodec_get_pix_fmt_name(avctx->pix_fmt));
354 return -1;
355 }
356
357 return dvvideo_init(avctx);
358 }
359
360 // #define VLC_DEBUG
361 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
362
363 typedef struct BlockInfo {
364 const uint32_t *factor_table;
365 const uint8_t *scan_table;
366 uint8_t pos; /* position in block */
367 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
368 uint8_t partial_bit_count;
369 uint16_t partial_bit_buffer;
370 int shift_offset;
371 } BlockInfo;
372
373 /* bit budget for AC only in 5 MBs */
374 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
375 /* see dv_88_areas and dv_248_areas for details */
376 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
377
378 static inline int put_bits_left(PutBitContext* s)
379 {
380 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
381 }
382
383 /* decode ac coefficients */
384 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
385 {
386 int last_index = gb->size_in_bits;
387 const uint8_t *scan_table = mb->scan_table;
388 const uint32_t *factor_table = mb->factor_table;
389 int pos = mb->pos;
390 int partial_bit_count = mb->partial_bit_count;
391 int level, run, vlc_len, index;
392
393 OPEN_READER(re, gb);
394 UPDATE_CACHE(re, gb);
395
396 /* if we must parse a partial vlc, we do it here */
397 if (partial_bit_count > 0) {
398 re_cache = ((unsigned)re_cache >> partial_bit_count) |
399 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
400 re_index -= partial_bit_count;
401 mb->partial_bit_count = 0;
402 }
403
404 /* get the AC coefficients until last_index is reached */
405 for (;;) {
406 #ifdef VLC_DEBUG
407 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
408 #endif
409 /* our own optimized GET_RL_VLC */
410 index = NEG_USR32(re_cache, TEX_VLC_BITS);
411 vlc_len = dv_rl_vlc[index].len;
412 if (vlc_len < 0) {
413 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
414 vlc_len = TEX_VLC_BITS - vlc_len;
415 }
416 level = dv_rl_vlc[index].level;
417 run = dv_rl_vlc[index].run;
418
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;
428
429 #ifdef VLC_DEBUG
430 printf("run=%d level=%d\n", run, level);
431 #endif
432 pos += run;
433 if (pos >= 64)
434 break;
435
436 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
437 block[scan_table[pos]] = level;
438
439 UPDATE_CACHE(re, gb);
440 }
441 CLOSE_READER(re, gb);
442 mb->pos = pos;
443 }
444
445 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
446 {
447 int bits_left = get_bits_left(gb);
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;
451 }
452 if (bits_left > 0) {
453 put_bits(pb, bits_left, get_bits(gb, bits_left));
454 }
455 }
456
457 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
458 {
459 *mb_x = work_chunk->mb_coordinates[m] & 0xff;
460 *mb_y = work_chunk->mb_coordinates[m] >> 8;
461
462 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
463 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
464 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
465 }
466 }
467
468 /* mb_x and mb_y are in units of 8 pixels */
469 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
470 {
471 DVVideoContext *s = avctx->priv_data;
472 DVwork_chunk *work_chunk = arg;
473 int quant, dc, dct_mode, class1, j;
474 int mb_index, mb_x, mb_y, last_index;
475 int y_stride, linesize;
476 DCTELEM *block, *block1;
477 int c_offset;
478 uint8_t *y_ptr;
479 const uint8_t *buf_ptr;
480 PutBitContext pb, vs_pb;
481 GetBitContext gb;
482 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
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 */
486 const int log2_blocksize = 3-s->avctx->lowres;
487 int is_field_mode[5];
488
489 assert((((int)mb_bit_buffer) & 7) == 0);
490 assert((((int)vs_bit_buffer) & 7) == 0);
491
492 memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
493
494 /* pass 1 : read DC and AC coefficients in blocks */
495 buf_ptr = &s->buf[work_chunk->buf_offset*80];
496 block1 = &sblock[0][0];
497 mb1 = mb_data;
498 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
499 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
500 /* skip header */
501 quant = buf_ptr[3] & 0x0f;
502 buf_ptr += 4;
503 init_put_bits(&pb, mb_bit_buffer, 80);
504 mb = mb1;
505 block = block1;
506 is_field_mode[mb_index] = 0;
507 for (j = 0; j < s->sys->bpm; j++) {
508 last_index = s->sys->block_sizes[j];
509 init_get_bits(&gb, buf_ptr, last_index);
510
511 /* get the dc */
512 dc = get_sbits(&gb, 9);
513 dct_mode = get_bits1(&gb);
514 class1 = get_bits(&gb, 2);
515 if (DV_PROFILE_IS_HD(s->sys)) {
516 mb->idct_put = s->idct_put[0];
517 mb->scan_table = s->dv_zigzag[0];
518 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
519 is_field_mode[mb_index] |= !j && dct_mode;
520 } else {
521 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
522 mb->scan_table = s->dv_zigzag[dct_mode];
523 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
524 (quant + dv_quant_offset[class1])*64];
525 }
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;
532 mb->pos = 0;
533 mb->partial_bit_count = 0;
534
535 #ifdef VLC_DEBUG
536 printf("MB block: %d, %d ", mb_index, j);
537 #endif
538 dv_decode_ac(&gb, mb, block);
539
540 /* write the remaining bits in a new buffer only if the
541 block is finished */
542 if (mb->pos >= 64)
543 bit_copy(&pb, &gb);
544
545 block += 64;
546 mb++;
547 }
548
549 /* pass 2 : we can do it just after */
550 #ifdef VLC_DEBUG
551 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
552 #endif
553 block = block1;
554 mb = mb1;
555 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
556 flush_put_bits(&pb);
557 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
558 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
559 dv_decode_ac(&gb, mb, block);
560 /* if still not finished, no need to parse other blocks */
561 if (mb->pos < 64)
562 break;
563 }
564 }
565 /* all blocks are finished, so the extra bytes can be used at
566 the video segment level */
567 if (j >= s->sys->bpm)
568 bit_copy(&vs_pb, &gb);
569 }
570
571 /* we need a pass other the whole video segment */
572 #ifdef VLC_DEBUG
573 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
574 #endif
575 block = &sblock[0][0];
576 mb = mb_data;
577 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
578 flush_put_bits(&vs_pb);
579 for (mb_index = 0; mb_index < 5; mb_index++) {
580 for (j = 0; j < s->sys->bpm; j++) {
581 if (mb->pos < 64) {
582 #ifdef VLC_DEBUG
583 printf("start %d:%d\n", mb_index, j);
584 #endif
585 dv_decode_ac(&gb, mb, block);
586 }
587 if (mb->pos >= 64 && mb->pos < 127)
588 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
589 block += 64;
590 mb++;
591 }
592 }
593
594 /* compute idct and place blocks */
595 block = &sblock[0][0];
596 mb = mb_data;
597 for (mb_index = 0; mb_index < 5; mb_index++) {
598 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
599
600 /* idct_put'ting luminance */
601 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
602 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
603 (s->sys->height >= 720 && mb_y != 134)) {
604 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
605 } else {
606 y_stride = (2 << log2_blocksize);
607 }
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);
611 if (s->sys->video_stype == 4) { /* SD 422 */
612 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
613 } else {
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);
617 }
618 mb += 4;
619 block += 4*64;
620
621 /* idct_put'ting chrominance */
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--) {
625 uint8_t *c_ptr = s->picture.data[j] + c_offset;
626 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
627 uint64_t aligned_pixels[64/8];
628 uint8_t *pixels = (uint8_t*)aligned_pixels;
629 uint8_t *c_ptr1, *ptr1;
630 int x, y;
631 mb->idct_put(pixels, 8, block);
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];
638 }
639 }
640 block += 64; mb++;
641 } else {
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;
646 if (s->sys->bpm == 8) {
647 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
648 }
649 }
650 }
651 }
652 return 0;
653 }
654
655 #if CONFIG_SMALL
656 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
657 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
658 {
659 int size;
660 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
661 *vlc = dv_vlc_map[run][level].vlc | sign;
662 size = dv_vlc_map[run][level].size;
663 }
664 else {
665 if (level < DV_VLC_MAP_LEV_SIZE) {
666 *vlc = dv_vlc_map[0][level].vlc | sign;
667 size = dv_vlc_map[0][level].size;
668 } else {
669 *vlc = 0xfe00 | (level << 1) | sign;
670 size = 16;
671 }
672 if (run) {
673 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
674 (0x1f80 | (run - 1))) << size;
675 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
676 }
677 }
678
679 return size;
680 }
681
682 static av_always_inline int dv_rl2vlc_size(int run, int level)
683 {
684 int size;
685
686 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
687 size = dv_vlc_map[run][level].size;
688 }
689 else {
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 }
694 }
695 return size;
696 }
697 #else
698 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
699 {
700 *vlc = dv_vlc_map[run][l].vlc | sign;
701 return dv_vlc_map[run][l].size;
702 }
703
704 static av_always_inline int dv_rl2vlc_size(int run, int l)
705 {
706 return dv_vlc_map[run][l].size;
707 }
708 #endif
709
710 typedef struct EncBlockInfo {
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;
721 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
722 } EncBlockInfo;
723
724 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
725 PutBitContext* pb_pool,
726 PutBitContext* pb_end)
727 {
728 int prev, bits_left;
729 PutBitContext* pb = pb_pool;
730 int size = bi->partial_bit_count;
731 uint32_t vlc = bi->partial_bit_buffer;
732
733 bi->partial_bit_count = bi->partial_bit_buffer = 0;
734 for (;;){
735 /* Find suitable storage space */
736 for (; size > (bits_left = put_bits_left(pb)); pb++) {
737 if (bits_left) {
738 size -= bits_left;
739 put_bits(pb, bits_left, vlc >> size);
740 vlc = vlc & ((1 << size) - 1);
741 }
742 if (pb + 1 >= pb_end) {
743 bi->partial_bit_count = size;
744 bi->partial_bit_buffer = vlc;
745 return pb;
746 }
747 }
748
749 /* Store VLC */
750 put_bits(pb, size, vlc);
751
752 if (bi->cur_ac >= 64)
753 break;
754
755 /* Construct the next VLC */
756 prev = bi->cur_ac;
757 bi->cur_ac = bi->next[prev];
758 if (bi->cur_ac < 64){
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 */
762 }
763 }
764 return pb;
765 }
766
767 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
768 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
769 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
770 if (ps > 0) {
771 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
772 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
773 return (ps > is);
774 }
775 }
776
777 return 0;
778 }
779
780 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
781 {
782 const int *weight;
783 const uint8_t* zigzag_scan;
784 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
785 int i, area;
786 /* We offer two different methods for class number assignment: the
787 method suggested in SMPTE 314M Table 22, and an improved
788 method. The SMPTE method is very conservative; it assigns class
789 3 (i.e. severe quantization) to any block where the largest AC
790 component is greater than 36. FFmpeg's DV encoder tracks AC bit
791 consumption precisely, so there is no need to bias most blocks
792 towards strongly lossy compression. Instead, we assign class 2
793 to most blocks, and use class 3 only when strictly necessary
794 (for blocks whose largest AC component exceeds 255). */
795
796 #if 0 /* SMPTE spec method */
797 static const int classes[] = {12, 24, 36, 0xffff};
798 #else /* improved FFmpeg method */
799 static const int classes[] = {-1, -1, 255, 0xffff};
800 #endif
801 int max = classes[0];
802 int prev = 0;
803
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) {
811 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
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. */
817 memset(blk, 0, 64*sizeof(*blk));
818 bi->dct_mode = 0;
819 }
820 bi->mb[0] = blk[0];
821
822 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
823 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
824
825 for (area = 0; area < 4; area++) {
826 bi->prev[area] = prev;
827 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
828 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
829 int level = blk[zigzag_scan[i]];
830
831 if (level + 15 > 30U) {
832 bi->sign[i] = (level >> 31) & 1;
833 /* weigh it and and shift down into range, adding for rounding */
834 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
835 AND the 2x doubling of the weights */
836 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
837 bi->mb[i] = level;
838 if (level > max)
839 max = level;
840 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
841 bi->next[prev]= i;
842 prev = i;
843 }
844 }
845 }
846 bi->next[prev]= i;
847 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
848
849 bi->cno += bias;
850
851 if (bi->cno >= 3) {
852 bi->cno = 3;
853 prev = 0;
854 i = bi->next[prev];
855 for (area = 0; area < 4; area++) {
856 bi->prev[area] = prev;
857 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
858 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
859 bi->mb[i] >>= 1;
860
861 if (bi->mb[i]) {
862 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
863 bi->next[prev]= i;
864 prev = i;
865 }
866 }
867 }
868 bi->next[prev]= i;
869 }
870
871 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
872 }
873
874 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
875 {
876 int size[5];
877 int i, j, k, a, prev, a2;
878 EncBlockInfo* b;
879
880 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
881 do {
882 b = blks;
883 for (i = 0; i < 5; i++) {
884 if (!qnos[i])
885 continue;
886
887 qnos[i]--;
888 size[i] = 0;
889 for (j = 0; j < 6; j++, b++) {
890 for (a = 0; a < 4; a++) {
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]++;
894 prev = b->prev[a];
895 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
896 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
897 b->mb[k] >>= 1;
898 if (b->mb[k]) {
899 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
900 prev = k;
901 } else {
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++)
904 b->prev[a2] = prev;
905 assert(a2 < 4);
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]]);
909 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
910 b->prev[a2] = prev;
911 }
912 b->next[prev] = b->next[k];
913 }
914 }
915 b->prev[a+1]= prev;
916 }
917 size[i] += b->bit_size[a];
918 }
919 }
920 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
921 return;
922 }
923 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
924
925
926 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
927 b = blks;
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){
933 b->next[prev] = b->next[k];
934 }else{
935 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
936 prev = k;
937 }
938 }
939 }
940 }
941 }
942
943 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
944 {
945 DVVideoContext *s = avctx->priv_data;
946 DVwork_chunk *work_chunk = arg;
947 int mb_index, i, j;
948 int mb_x, mb_y, c_offset, linesize, y_stride;
949 uint8_t* y_ptr;
950 uint8_t* dif;
951 uint8_t scratch[64];
952 EncBlockInfo enc_blks[5*DV_MAX_BPM];
953 PutBitContext pbs[5*DV_MAX_BPM];
954 PutBitContext* pb;
955 EncBlockInfo* enc_blk;
956 int vs_bit_size = 0;
957 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
958 int* qnosp = &qnos[0];
959
960 dif = &s->buf[work_chunk->buf_offset*80];
961 enc_blk = &enc_blks[0];
962 for (mb_index = 0; mb_index < 5; mb_index++) {
963 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
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 }
973 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
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 */
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);
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);
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 }
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);
1015 }
1016 }
1017 }
1018
1019 if (vs_total_ac_bits < vs_bit_size)
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;
1025
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;
1032
1033 init_put_bits(&pbs[j], dif, sz);
1034 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1035 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1036 put_bits(&pbs[j], 2, enc_blks[j].cno);
1037
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];
1044 for (i=0; i<s->sys->bpm; i++) {
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]);
1047 }
1048 }
1049
1050 /* Third and final pass over the whole video segment space */
1051 pb = &pbs[0];
1052 for (j=0; j<5*s->sys->bpm; j++) {
1053 if (enc_blks[j].partial_bit_count)
1054 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1055 if (enc_blks[j].partial_bit_count)
1056 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1057 }
1058
1059 for (j=0; j<5*s->sys->bpm; j++) {
1060 int pos;
1061 int size = pbs[j].size_in_bits >> 3;
1062 flush_put_bits(&pbs[j]);
1063 pos = put_bits_count(&pbs[j]) >> 3;
1064 if (pos > size) {
1065 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1066 return -1;
1067 }
1068 memset(pbs[j].buf + pos, 0xff, size - pos);
1069 }
1070
1071 return 0;
1072 }
1073
1074 #if CONFIG_DVVIDEO_DECODER
1075 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1076 144000 bytes for PAL - or twice those for 50Mbps) */
1077 static int dvvideo_decode_frame(AVCodecContext *avctx,
1078 void *data, int *data_size,
1079 AVPacket *avpkt)
1080 {
1081 const uint8_t *buf = avpkt->data;
1082 int buf_size = avpkt->size;
1083 DVVideoContext *s = avctx->priv_data;
1084
1085 s->sys = ff_dv_frame_profile(s->sys, buf, buf_size);
1086 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1087 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1088 return -1; /* NOTE: we only accept several full frames */
1089 }
1090
1091 if (s->picture.data[0])
1092 avctx->release_buffer(avctx, &s->picture);
1093
1094 s->picture.reference = 0;
1095 s->picture.key_frame = 1;
1096 s->picture.pict_type = FF_I_TYPE;
1097 avctx->pix_fmt = s->sys->pix_fmt;
1098 avctx->time_base = s->sys->time_base;
1099 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1100 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1101 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1102 return -1;
1103 }
1104 s->picture.interlaced_frame = 1;
1105 s->picture.top_field_first = 0;
1106
1107 s->buf = buf;
1108 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1109 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1110
1111 emms_c();
1112
1113 /* return image */
1114 *data_size = sizeof(AVFrame);
1115 *(AVFrame*)data = s->picture;
1116
1117 return s->sys->frame_size;
1118 }
1119 #endif /* CONFIG_DVVIDEO_DECODER */
1120
1121
1122 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1123 uint8_t* buf)
1124 {
1125 /*
1126 * Here's what SMPTE314M says about these two:
1127 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1128 * as track application IDs (APTn = 001, AP1n =
1129 * 001, AP2n = 001, AP3n = 001), if the source signal
1130 * comes from a digital VCR. If the signal source is
1131 * unknown, all bits for these data shall be set to 1.
1132 * (page 12) STYPE: STYPE defines a signal type of video signal
1133 * 00000b = 4:1:1 compression
1134 * 00100b = 4:2:2 compression
1135 * XXXXXX = Reserved
1136 * Now, I've got two problems with these statements:
1137 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1138 * It seems that for PAL as defined in IEC 61834 we have to set
1139 * APT to 000 and for SMPTE314M to 001.
1140 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1141 * compression scheme (if any).
1142 */
1143 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1144
1145 uint8_t aspect = 0;
1146 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1147 aspect = 0x02;
1148
1149 buf[0] = (uint8_t)pack_id;
1150 switch (pack_id) {
1151 case dv_header525: /* I can't imagine why these two weren't defined as real */
1152 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
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 */
1156 (0x0f << 3) | /* reserved -- always 1 */
1157 (apt & 0x07); /* AP1: Audio application ID */
1158 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1159 (0x0f << 3) | /* reserved -- always 1 */
1160 (apt & 0x07); /* AP2: Video application ID */
1161 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1162 (0x0f << 3) | /* reserved -- always 1 */
1163 (apt & 0x07); /* AP3: Subcode application ID */
1164 break;
1165 case dv_video_source:
1166 buf[1] = 0xff; /* reserved -- always 1 */
1167 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1168 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1169 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1170 0xf; /* reserved -- always 1 */
1171 buf[3] = (3 << 6) | /* reserved -- always 1 */
1172 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1173 c->sys->video_stype; /* signal type video compression */
1174 buf[4] = 0xff; /* VISC: 0xff -- no information */
1175 break;
1176 case dv_video_control:
1177 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1178 0x3f; /* reserved -- always 1 */
1179 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1180 aspect;
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 */
1184 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1185 0xc; /* reserved -- always b1100 */
1186 buf[4] = 0xff; /* reserved -- always 1 */
1187 break;
1188 default:
1189 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1190 }
1191 return 5;
1192 }
1193
1194 #if CONFIG_DVVIDEO_ENCODER
1195 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1196 {
1197 int chan, i, j, k;
1198
1199 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1200 for (i = 0; i < c->sys->difseg_size; i++) {
1201 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1202
1203 /* DV header: 1DIF */
1204 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1205 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1206 buf += 72; /* unused bytes */
1207
1208 /* DV subcode: 2DIFs */
1209 for (j = 0; j < 2; j++) {
1210 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1211 for (k = 0; k < 6; k++)
1212 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1213 buf += 29; /* unused bytes */
1214 }
1215
1216 /* DV VAUX: 3DIFS */
1217 for (j = 0; j < 3; j++) {
1218 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1219 buf += dv_write_pack(dv_video_source, c, buf);
1220 buf += dv_write_pack(dv_video_control, c, buf);
1221 buf += 7*5;
1222 buf += dv_write_pack(dv_video_source, c, buf);
1223 buf += dv_write_pack(dv_video_control, c, buf);
1224 buf += 4*5 + 2; /* unused bytes */
1225 }
1226
1227 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1228 for (j = 0; j < 135; j++) {
1229 if (j%15 == 0) {
1230 memset(buf, 0xff, 80);
1231 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1232 buf += 77; /* audio control & shuffled PCM audio */
1233 }
1234 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1235 buf += 77; /* 1 video macroblock: 1 bytes control
1236 4 * 14 bytes Y 8x8 data
1237 10 bytes Cr 8x8 data
1238 10 bytes Cb 8x8 data */
1239 }
1240 }
1241 }
1242 }
1243
1244
1245 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1246 void *data)
1247 {
1248 DVVideoContext *s = c->priv_data;
1249
1250 s->sys = ff_dv_codec_profile(c);
1251 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1252 return -1;
1253
1254 c->pix_fmt = s->sys->pix_fmt;
1255 s->picture = *((AVFrame *)data);
1256 s->picture.key_frame = 1;
1257 s->picture.pict_type = FF_I_TYPE;
1258
1259 s->buf = buf;
1260 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1261 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1262
1263 emms_c();
1264
1265 dv_format_frame(s, buf);
1266
1267 return s->sys->frame_size;
1268 }
1269 #endif
1270
1271 static int dvvideo_close(AVCodecContext *c)
1272 {
1273 DVVideoContext *s = c->priv_data;
1274
1275 if (s->picture.data[0])
1276 c->release_buffer(c, &s->picture);
1277
1278 return 0;
1279 }
1280
1281
1282 #if CONFIG_DVVIDEO_ENCODER
1283 AVCodec dvvideo_encoder = {
1284 "dvvideo",
1285 CODEC_TYPE_VIDEO,
1286 CODEC_ID_DVVIDEO,
1287 sizeof(DVVideoContext),
1288 dvvideo_init_encoder,
1289 dvvideo_encode_frame,
1290 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1291 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1292 };
1293 #endif // CONFIG_DVVIDEO_ENCODER
1294
1295 #if CONFIG_DVVIDEO_DECODER
1296 AVCodec dvvideo_decoder = {
1297 "dvvideo",
1298 CODEC_TYPE_VIDEO,
1299 CODEC_ID_DVVIDEO,
1300 sizeof(DVVideoContext),
1301 dvvideo_init,
1302 NULL,
1303 dvvideo_close,
1304 dvvideo_decode_frame,
1305 CODEC_CAP_DR1,
1306 NULL,
1307 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1308 };
1309 #endif