1/* 2 * DV encoder 3 * Copyright (c) 2003 Roman Shaposhnik 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/** 23 * @file 24 * DV encoder 25 */ 26 27#include "libavutil/attributes.h" 28#include "libavutil/pixdesc.h" 29#include "config.h" 30#include "avcodec.h" 31#include "dsputil.h" 32#include "fdctdsp.h" 33#include "internal.h" 34#include "pixblockdsp.h" 35#include "put_bits.h" 36#include "dv.h" 37#include "dv_tablegen.h" 38#include "dv_profile_internal.h" 39 40static av_cold int dvvideo_encode_init(AVCodecContext *avctx) 41{ 42 DVVideoContext *s = avctx->priv_data; 43 DSPContext dsp; 44 FDCTDSPContext fdsp; 45 PixblockDSPContext pdsp; 46 int ret; 47 48 s->sys = avpriv_dv_codec_profile(avctx); 49 if (!s->sys) { 50 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. " 51 "Valid DV profiles are:\n", 52 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt)); 53 ff_dv_print_profiles(avctx, AV_LOG_ERROR); 54 return AVERROR(EINVAL); 55 } 56 if (avctx->height > 576) { 57 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n"); 58 return AVERROR_PATCHWELCOME; 59 } 60 ret = ff_dv_init_dynamic_tables(s, s->sys); 61 if (ret < 0) { 62 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n"); 63 return ret; 64 } 65 66 avctx->coded_frame = av_frame_alloc(); 67 if (!avctx->coded_frame) 68 return AVERROR(ENOMEM); 69 70 dv_vlc_map_tableinit(); 71 72 memset(&dsp,0, sizeof(dsp)); 73 ff_dsputil_init(&dsp, avctx); 74 ff_fdctdsp_init(&fdsp, avctx); 75 ff_pixblockdsp_init(&pdsp, avctx); 76 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp); 77 78 s->get_pixels = pdsp.get_pixels; 79 s->ildct_cmp = dsp.ildct_cmp[5]; 80 81 s->fdct[0] = fdsp.fdct; 82 s->fdct[1] = fdsp.fdct248; 83 84 return ff_dvvideo_init(avctx); 85} 86 87/* bit budget for AC only in 5 MBs */ 88static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; 89static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; 90 91#if CONFIG_SMALL 92/* Converts run and level (where level != 0) pair into VLC, returning bit size */ 93static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) 94{ 95 int size; 96 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { 97 *vlc = dv_vlc_map[run][level].vlc | sign; 98 size = dv_vlc_map[run][level].size; 99 } 100 else { 101 if (level < DV_VLC_MAP_LEV_SIZE) { 102 *vlc = dv_vlc_map[0][level].vlc | sign; 103 size = dv_vlc_map[0][level].size; 104 } else { 105 *vlc = 0xfe00 | (level << 1) | sign; 106 size = 16; 107 } 108 if (run) { 109 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : 110 (0x1f80 | (run - 1))) << size; 111 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; 112 } 113 } 114 115 return size; 116} 117 118static av_always_inline int dv_rl2vlc_size(int run, int level) 119{ 120 int size; 121 122 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { 123 size = dv_vlc_map[run][level].size; 124 } 125 else { 126 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; 127 if (run) { 128 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; 129 } 130 } 131 return size; 132} 133#else 134static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) 135{ 136 *vlc = dv_vlc_map[run][l].vlc | sign; 137 return dv_vlc_map[run][l].size; 138} 139 140static av_always_inline int dv_rl2vlc_size(int run, int l) 141{ 142 return dv_vlc_map[run][l].size; 143} 144#endif 145 146typedef struct EncBlockInfo { 147 int area_q[4]; 148 int bit_size[4]; 149 int prev[5]; 150 int cur_ac; 151 int cno; 152 int dct_mode; 153 int16_t mb[64]; 154 uint8_t next[64]; 155 uint8_t sign[64]; 156 uint8_t partial_bit_count; 157 uint32_t partial_bit_buffer; /* we can't use uint16_t here */ 158} EncBlockInfo; 159 160static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, 161 PutBitContext* pb_pool, 162 PutBitContext* pb_end) 163{ 164 int prev, bits_left; 165 PutBitContext* pb = pb_pool; 166 int size = bi->partial_bit_count; 167 uint32_t vlc = bi->partial_bit_buffer; 168 169 bi->partial_bit_count = bi->partial_bit_buffer = 0; 170 for (;;){ 171 /* Find suitable storage space */ 172 for (; size > (bits_left = put_bits_left(pb)); pb++) { 173 if (bits_left) { 174 size -= bits_left; 175 put_bits(pb, bits_left, vlc >> size); 176 vlc = vlc & ((1 << size) - 1); 177 } 178 if (pb + 1 >= pb_end) { 179 bi->partial_bit_count = size; 180 bi->partial_bit_buffer = vlc; 181 return pb; 182 } 183 } 184 185 /* Store VLC */ 186 put_bits(pb, size, vlc); 187 188 if (bi->cur_ac >= 64) 189 break; 190 191 /* Construct the next VLC */ 192 prev = bi->cur_ac; 193 bi->cur_ac = bi->next[prev]; 194 if (bi->cur_ac < 64){ 195 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); 196 } else { 197 size = 4; vlc = 6; /* End Of Block stamp */ 198 } 199 } 200 return pb; 201} 202 203static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) { 204 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) { 205 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400; 206 if (ps > 0) { 207 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) + 208 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4); 209 return ps > is; 210 } 211 } 212 213 return 0; 214} 215 216static const int dv_weight_bits = 18; 217static const int dv_weight_88[64] = { 218 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536, 219 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935, 220 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916, 221 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433, 222 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704, 223 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568, 224 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627, 225 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258, 226}; 227static const int dv_weight_248[64] = { 228 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754, 229 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536, 230 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568, 231 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965, 232 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627, 233 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965, 234 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364, 235 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651, 236}; 237 238static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias) 239{ 240 const int *weight; 241 const uint8_t* zigzag_scan; 242 LOCAL_ALIGNED_16(int16_t, blk, [64]); 243 int i, area; 244 /* We offer two different methods for class number assignment: the 245 method suggested in SMPTE 314M Table 22, and an improved 246 method. The SMPTE method is very conservative; it assigns class 247 3 (i.e. severe quantization) to any block where the largest AC 248 component is greater than 36. FFmpeg's DV encoder tracks AC bit 249 consumption precisely, so there is no need to bias most blocks 250 towards strongly lossy compression. Instead, we assign class 2 251 to most blocks, and use class 3 only when strictly necessary 252 (for blocks whose largest AC component exceeds 255). */ 253 254#if 0 /* SMPTE spec method */ 255 static const int classes[] = {12, 24, 36, 0xffff}; 256#else /* improved FFmpeg method */ 257 static const int classes[] = {-1, -1, 255, 0xffff}; 258#endif 259 int max = classes[0]; 260 int prev = 0; 261 262 av_assert2((((int)blk) & 15) == 0); 263 264 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0; 265 bi->partial_bit_count = 0; 266 bi->partial_bit_buffer = 0; 267 bi->cur_ac = 0; 268 if (data) { 269 bi->dct_mode = dv_guess_dct_mode(s, data, linesize); 270 s->get_pixels(blk, data, linesize); 271 s->fdct[bi->dct_mode](blk); 272 } else { 273 /* We rely on the fact that encoding all zeros leads to an immediate EOB, 274 which is precisely what the spec calls for in the "dummy" blocks. */ 275 memset(blk, 0, 64*sizeof(*blk)); 276 bi->dct_mode = 0; 277 } 278 bi->mb[0] = blk[0]; 279 280 zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct; 281 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88; 282 283 for (area = 0; area < 4; area++) { 284 bi->prev[area] = prev; 285 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) 286 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) { 287 int level = blk[zigzag_scan[i]]; 288 289 if (level + 15 > 30U) { 290 bi->sign[i] = (level >> 31) & 1; 291 /* weight it and shift down into range, adding for rounding */ 292 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT 293 AND the 2x doubling of the weights */ 294 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4); 295 bi->mb[i] = level; 296 if (level > max) 297 max = level; 298 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); 299 bi->next[prev]= i; 300 prev = i; 301 } 302 } 303 } 304 bi->next[prev]= i; 305 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++); 306 307 bi->cno += bias; 308 309 if (bi->cno >= 3) { 310 bi->cno = 3; 311 prev = 0; 312 i = bi->next[prev]; 313 for (area = 0; area < 4; area++) { 314 bi->prev[area] = prev; 315 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) 316 for (; i < mb_area_start[area+1]; i = bi->next[i]) { 317 bi->mb[i] >>= 1; 318 319 if (bi->mb[i]) { 320 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); 321 bi->next[prev]= i; 322 prev = i; 323 } 324 } 325 } 326 bi->next[prev]= i; 327 } 328 329 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3]; 330} 331 332static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) 333{ 334 int size[5]; 335 int i, j, k, a, prev, a2; 336 EncBlockInfo* b; 337 338 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24; 339 do { 340 b = blks; 341 for (i = 0; i < 5; i++) { 342 if (!qnos[i]) 343 continue; 344 345 qnos[i]--; 346 size[i] = 0; 347 for (j = 0; j < 6; j++, b++) { 348 for (a = 0; a < 4; a++) { 349 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) { 350 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) 351 b->area_q[a]++; 352 prev = b->prev[a]; 353 av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); 354 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) { 355 b->mb[k] >>= 1; 356 if (b->mb[k]) { 357 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); 358 prev = k; 359 } else { 360 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){ 361 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++) 362 b->prev[a2] = prev; 363 av_assert2(a2 < 4); 364 av_assert2(b->mb[b->next[k]]); 365 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) 366 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); 367 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k)); 368 b->prev[a2] = prev; 369 } 370 b->next[prev] = b->next[k]; 371 } 372 } 373 b->prev[a+1]= prev; 374 } 375 size[i] += b->bit_size[a]; 376 } 377 } 378 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) 379 return; 380 } 381 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); 382 383 384 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){ 385 b = blks; 386 size[0] = 5 * 6 * 4; //EOB 387 for (j = 0; j < 6 *5; j++, b++) { 388 prev = b->prev[0]; 389 for (k = b->next[prev]; k < 64; k = b->next[k]) { 390 if (b->mb[k] < a && b->mb[k] > -a){ 391 b->next[prev] = b->next[k]; 392 }else{ 393 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); 394 prev = k; 395 } 396 } 397 } 398 } 399} 400 401static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) 402{ 403 DVVideoContext *s = avctx->priv_data; 404 DVwork_chunk *work_chunk = arg; 405 int mb_index, i, j; 406 int mb_x, mb_y, c_offset, linesize, y_stride; 407 uint8_t* y_ptr; 408 uint8_t* dif; 409 LOCAL_ALIGNED_8(uint8_t, scratch, [128]); 410 EncBlockInfo enc_blks[5*DV_MAX_BPM]; 411 PutBitContext pbs[5*DV_MAX_BPM]; 412 PutBitContext* pb; 413 EncBlockInfo* enc_blk; 414 int vs_bit_size = 0; 415 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */ 416 int* qnosp = &qnos[0]; 417 418 dif = &s->buf[work_chunk->buf_offset*80]; 419 enc_blk = &enc_blks[0]; 420 for (mb_index = 0; mb_index < 5; mb_index++) { 421 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); 422 423 /* initializing luminance blocks */ 424 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) || 425 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) || 426 (s->sys->height >= 720 && mb_y != 134)) { 427 y_stride = s->frame->linesize[0] << 3; 428 } else { 429 y_stride = 16; 430 } 431 y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3); 432 linesize = s->frame->linesize[0]; 433 434 if (s->sys->video_stype == 4) { /* SD 422 */ 435 vs_bit_size += 436 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + 437 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) + 438 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) + 439 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0); 440 } else { 441 vs_bit_size += 442 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + 443 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) + 444 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) + 445 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0); 446 } 447 enc_blk += 4; 448 449 /* initializing chrominance blocks */ 450 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] + 451 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3); 452 for (j = 2; j; j--) { 453 uint8_t *c_ptr = s->frame->data[j] + c_offset; 454 linesize = s->frame->linesize[j]; 455 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3); 456 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) { 457 uint8_t* d; 458 uint8_t* b = scratch; 459 for (i = 0; i < 8; i++) { 460 d = c_ptr + (linesize << 3); 461 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3]; 462 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; 463 c_ptr += linesize; 464 b += 16; 465 } 466 c_ptr = scratch; 467 linesize = 16; 468 } 469 470 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1); 471 if (s->sys->bpm == 8) { 472 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1); 473 } 474 } 475 } 476 477 if (vs_total_ac_bits < vs_bit_size) 478 dv_guess_qnos(&enc_blks[0], qnosp); 479 480 /* DIF encoding process */ 481 for (j=0; j<5*s->sys->bpm;) { 482 int start_mb = j; 483 484 dif[3] = *qnosp++; 485 dif += 4; 486 487 /* First pass over individual cells only */ 488 for (i=0; i<s->sys->bpm; i++, j++) { 489 int sz = s->sys->block_sizes[i]>>3; 490 491 init_put_bits(&pbs[j], dif, sz); 492 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2); 493 put_bits(&pbs[j], 1, enc_blks[j].dct_mode); 494 put_bits(&pbs[j], 2, enc_blks[j].cno); 495 496 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); 497 dif += sz; 498 } 499 500 /* Second pass over each MB space */ 501 pb = &pbs[start_mb]; 502 for (i=0; i<s->sys->bpm; i++) { 503 if (enc_blks[start_mb+i].partial_bit_count) 504 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]); 505 } 506 } 507 508 /* Third and final pass over the whole video segment space */ 509 pb = &pbs[0]; 510 for (j=0; j<5*s->sys->bpm; j++) { 511 if (enc_blks[j].partial_bit_count) 512 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]); 513 if (enc_blks[j].partial_bit_count) 514 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n"); 515 } 516 517 for (j=0; j<5*s->sys->bpm; j++) { 518 int pos; 519 int size = pbs[j].size_in_bits >> 3; 520 flush_put_bits(&pbs[j]); 521 pos = put_bits_count(&pbs[j]) >> 3; 522 if (pos > size) { 523 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n"); 524 return -1; 525 } 526 memset(pbs[j].buf + pos, 0xff, size - pos); 527 } 528 529 return 0; 530} 531 532static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, 533 uint8_t* buf) 534{ 535 /* 536 * Here's what SMPTE314M says about these two: 537 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical 538 * as track application IDs (APTn = 001, AP1n = 539 * 001, AP2n = 001, AP3n = 001), if the source signal 540 * comes from a digital VCR. If the signal source is 541 * unknown, all bits for these data shall be set to 1. 542 * (page 12) STYPE: STYPE defines a signal type of video signal 543 * 00000b = 4:1:1 compression 544 * 00100b = 4:2:2 compression 545 * XXXXXX = Reserved 546 * Now, I've got two problems with these statements: 547 * 1. it looks like APT == 111b should be a safe bet, but it isn't. 548 * It seems that for PAL as defined in IEC 61834 we have to set 549 * APT to 000 and for SMPTE314M to 001. 550 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL 551 * compression scheme (if any). 552 */ 553 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1); 554 int fs = c->frame->top_field_first ? 0x00 : 0x40; 555 556 uint8_t aspect = 0; 557 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */ 558 aspect = 0x02; 559 560 buf[0] = (uint8_t)pack_id; 561 switch (pack_id) { 562 case dv_header525: /* I can't imagine why these two weren't defined as real */ 563 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */ 564 buf[1] = 0xf8 | /* reserved -- always 1 */ 565 (apt & 0x07); /* APT: Track application ID */ 566 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */ 567 (0x0f << 3) | /* reserved -- always 1 */ 568 (apt & 0x07); /* AP1: Audio application ID */ 569 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */ 570 (0x0f << 3) | /* reserved -- always 1 */ 571 (apt & 0x07); /* AP2: Video application ID */ 572 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */ 573 (0x0f << 3) | /* reserved -- always 1 */ 574 (apt & 0x07); /* AP3: Subcode application ID */ 575 break; 576 case dv_video_source: 577 buf[1] = 0xff; /* reserved -- always 1 */ 578 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */ 579 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */ 580 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */ 581 0xf; /* reserved -- always 1 */ 582 buf[3] = (3 << 6) | /* reserved -- always 1 */ 583 (c->sys->dsf << 5) | /* system: 60fields/50fields */ 584 c->sys->video_stype; /* signal type video compression */ 585 buf[4] = 0xff; /* VISC: 0xff -- no information */ 586 break; 587 case dv_video_control: 588 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */ 589 0x3f; /* reserved -- always 1 */ 590 buf[2] = 0xc8 | /* reserved -- always b11001xxx */ 591 aspect; 592 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */ 593 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */ 594 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */ 595 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */ 596 0xc; /* reserved -- always b1100 */ 597 buf[4] = 0xff; /* reserved -- always 1 */ 598 break; 599 default: 600 buf[1] = buf[2] = buf[3] = buf[4] = 0xff; 601 } 602 return 5; 603} 604 605static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, 606 uint8_t seq_num, uint8_t dif_num, 607 uint8_t* buf) 608{ 609 buf[0] = (uint8_t)t; /* Section type */ 610 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */ 611 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */ 612 7; /* reserved -- always 1 */ 613 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */ 614 return 3; 615} 616 617 618static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf) 619{ 620 if (syb_num == 0 || syb_num == 6) { 621 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */ 622 (0 << 4) | /* AP3 (Subcode application ID) */ 623 0x0f; /* reserved -- always 1 */ 624 } 625 else if (syb_num == 11) { 626 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */ 627 0x7f; /* reserved -- always 1 */ 628 } 629 else { 630 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */ 631 (0 << 4) | /* APT (Track application ID) */ 632 0x0f; /* reserved -- always 1 */ 633 } 634 buf[1] = 0xf0 | /* reserved -- always 1 */ 635 (syb_num & 0x0f); /* SSYB number 0 - 11 */ 636 buf[2] = 0xff; /* reserved -- always 1 */ 637 return 3; 638} 639 640static void dv_format_frame(DVVideoContext* c, uint8_t* buf) 641{ 642 int chan, i, j, k; 643 644 for (chan = 0; chan < c->sys->n_difchan; chan++) { 645 for (i = 0; i < c->sys->difseg_size; i++) { 646 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */ 647 648 /* DV header: 1DIF */ 649 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf); 650 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf); 651 buf += 72; /* unused bytes */ 652 653 /* DV subcode: 2DIFs */ 654 for (j = 0; j < 2; j++) { 655 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf); 656 for (k = 0; k < 6; k++) 657 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5; 658 buf += 29; /* unused bytes */ 659 } 660 661 /* DV VAUX: 3DIFS */ 662 for (j = 0; j < 3; j++) { 663 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf); 664 buf += dv_write_pack(dv_video_source, c, buf); 665 buf += dv_write_pack(dv_video_control, c, buf); 666 buf += 7*5; 667 buf += dv_write_pack(dv_video_source, c, buf); 668 buf += dv_write_pack(dv_video_control, c, buf); 669 buf += 4*5 + 2; /* unused bytes */ 670 } 671 672 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */ 673 for (j = 0; j < 135; j++) { 674 if (j%15 == 0) { 675 memset(buf, 0xff, 80); 676 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf); 677 buf += 77; /* audio control & shuffled PCM audio */ 678 } 679 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf); 680 buf += 77; /* 1 video macroblock: 1 bytes control 681 4 * 14 bytes Y 8x8 data 682 10 bytes Cr 8x8 data 683 10 bytes Cb 8x8 data */ 684 } 685 } 686 } 687} 688 689 690static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt, 691 const AVFrame *frame, int *got_packet) 692{ 693 DVVideoContext *s = c->priv_data; 694 int ret; 695 696 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0) 697 return ret; 698 699 c->pix_fmt = s->sys->pix_fmt; 700 s->frame = frame; 701 c->coded_frame->key_frame = 1; 702 c->coded_frame->pict_type = AV_PICTURE_TYPE_I; 703 704 s->buf = pkt->data; 705 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL, 706 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); 707 708 emms_c(); 709 710 dv_format_frame(s, pkt->data); 711 712 pkt->flags |= AV_PKT_FLAG_KEY; 713 *got_packet = 1; 714 715 return 0; 716} 717 718static int dvvideo_encode_close(AVCodecContext *avctx) 719{ 720 av_frame_free(&avctx->coded_frame); 721 return 0; 722} 723 724AVCodec ff_dvvideo_encoder = { 725 .name = "dvvideo", 726 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), 727 .type = AVMEDIA_TYPE_VIDEO, 728 .id = AV_CODEC_ID_DVVIDEO, 729 .priv_data_size = sizeof(DVVideoContext), 730 .init = dvvideo_encode_init, 731 .encode2 = dvvideo_encode_frame, 732 .close = dvvideo_encode_close, 733 .capabilities = CODEC_CAP_SLICE_THREADS, 734 .pix_fmts = (const enum AVPixelFormat[]) { 735 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE 736 }, 737}; 738