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 Libav. 20 * 21 * Libav 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 * Libav 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 Libav; 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 38 * DV codec. 39 */ 40 41#include "libavutil/pixdesc.h" 42#include "avcodec.h" 43#include "dsputil.h" 44#include "get_bits.h" 45#include "put_bits.h" 46#include "simple_idct.h" 47#include "dvdata.h" 48#include "dv_tablegen.h" 49 50//#undef NDEBUG 51//#include <assert.h> 52 53typedef struct DVVideoContext { 54 const DVprofile *sys; 55 AVFrame picture; 56 AVCodecContext *avctx; 57 uint8_t *buf; 58 59 uint8_t dv_zigzag[2][64]; 60 61 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); 62 void (*fdct[2])(DCTELEM *block); 63 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block); 64 me_cmp_func ildct_cmp; 65} DVVideoContext; 66 67#define TEX_VLC_BITS 9 68 69/* XXX: also include quantization */ 70static RL_VLC_ELEM dv_rl_vlc[1184]; 71 72static inline int dv_work_pool_size(const DVprofile *d) 73{ 74 int size = d->n_difchan*d->difseg_size*27; 75 if (DV_PROFILE_IS_1080i50(d)) 76 size -= 3*27; 77 if (DV_PROFILE_IS_720p50(d)) 78 size -= 4*27; 79 return size; 80} 81 82static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot, 83 uint16_t *tbl) 84{ 85 static const uint8_t off[] = { 2, 6, 8, 0, 4 }; 86 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 }; 87 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 }; 88 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 }; 89 90 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40}; 91 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 }; 92 93 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0, 94 0, 1, 2, 2, 1, 0, 95 0, 1, 2, 2, 1, 0, 96 0, 1, 2, 2, 1, 0, 97 0, 1, 2}; 98 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, 99 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, 100 0, 1, 2, 3, 4, 5}; 101 102 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */ 103 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0}, 104 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1}, 105 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2}, 106 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3}, 107 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0}, 108 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1}, 109 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66}, 110 {10,64}, {10,65}, {10,66}, {20,64}, {20,65}, 111 {20,66}, {30,64}, {30,65}, {30,66}, {40,64}, 112 {40,65}, {40,66}, {50,64}, {50,65}, {50,66}, 113 {60,64}, {60,65}, {60,66}, {70,64}, {70,65}, 114 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}}; 115 116 int i, k, m; 117 int x, y, blk; 118 119 for (m=0; m<5; m++) { 120 switch (d->width) { 121 case 1440: 122 blk = (chan*11+seq)*27+slot; 123 124 if (chan == 0 && seq == 11) { 125 x = m*27+slot; 126 if (x<90) { 127 y = 0; 128 } else { 129 x = (x - 90)*2; 130 y = 67; 131 } 132 } else { 133 i = (4*chan + blk + off[m])%11; 134 k = (blk/11)%27; 135 136 x = shuf1[m] + (chan&1)*9 + k%9; 137 y = (i*3+k/9)*2 + (chan>>1) + 1; 138 } 139 tbl[m] = (x<<1)|(y<<9); 140 break; 141 case 1280: 142 blk = (chan*10+seq)*27+slot; 143 144 i = (4*chan + (seq/5) + 2*blk + off[m])%10; 145 k = (blk/5)%27; 146 147 x = shuf1[m]+(chan&1)*9 + k%9; 148 y = (i*3+k/9)*2 + (chan>>1) + 4; 149 150 if (x >= 80) { 151 x = remap[y][0]+((x-80)<<(y>59)); 152 y = remap[y][1]; 153 } 154 tbl[m] = (x<<1)|(y<<9); 155 break; 156 case 960: 157 blk = (chan*10+seq)*27+slot; 158 159 i = (4*chan + (seq/5) + 2*blk + off[m])%10; 160 k = (blk/5)%27 + (i&1)*3; 161 162 x = shuf2[m] + k%6 + 6*(chan&1); 163 y = l_start[i] + k/6 + 45*(chan>>1); 164 tbl[m] = (x<<1)|(y<<9); 165 break; 166 case 720: 167 switch (d->pix_fmt) { 168 case PIX_FMT_YUV422P: 169 x = shuf3[m] + slot/3; 170 y = serpent1[slot] + 171 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3; 172 tbl[m] = (x<<1)|(y<<8); 173 break; 174 case PIX_FMT_YUV420P: 175 x = shuf3[m] + slot/3; 176 y = serpent1[slot] + 177 ((seq + off[m]) % d->difseg_size)*3; 178 tbl[m] = (x<<1)|(y<<9); 179 break; 180 case PIX_FMT_YUV411P: 181 i = (seq + off[m]) % d->difseg_size; 182 k = slot + ((m==1||m==2)?3:0); 183 184 x = l_start_shuffled[m] + k/6; 185 y = serpent2[k] + i*6; 186 if (x>21) 187 y = y*2 - i*6; 188 tbl[m] = (x<<2)|(y<<8); 189 break; 190 } 191 default: 192 break; 193 } 194 } 195} 196 197static int dv_init_dynamic_tables(const DVprofile *d) 198{ 199 int j,i,c,s,p; 200 uint32_t *factor1, *factor2; 201 const int *iweight1, *iweight2; 202 203 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) { 204 p = i = 0; 205 for (c=0; c<d->n_difchan; c++) { 206 for (s=0; s<d->difseg_size; s++) { 207 p += 6; 208 for (j=0; j<27; j++) { 209 p += !(j%3); 210 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) && 211 !(DV_PROFILE_IS_720p50(d) && s > 9)) { 212 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]); 213 d->work_chunks[i++].buf_offset = p; 214 } 215 p += 5; 216 } 217 } 218 } 219 } 220 221 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) { 222 factor1 = &d->idct_factor[0]; 223 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816]; 224 if (d->height == 720) { 225 iweight1 = &dv_iweight_720_y[0]; 226 iweight2 = &dv_iweight_720_c[0]; 227 } else { 228 iweight1 = &dv_iweight_1080_y[0]; 229 iweight2 = &dv_iweight_1080_c[0]; 230 } 231 if (DV_PROFILE_IS_HD(d)) { 232 for (c = 0; c < 4; c++) { 233 for (s = 0; s < 16; s++) { 234 for (i = 0; i < 64; i++) { 235 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i]; 236 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i]; 237 } 238 } 239 } 240 } else { 241 iweight1 = &dv_iweight_88[0]; 242 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) { 243 for (s = 0; s < 22; s++) { 244 for (i = c = 0; c < 4; c++) { 245 for (; i < dv_quant_areas[c]; i++) { 246 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1); 247 *factor2++ = (*factor1++) << 1; 248 } 249 } 250 } 251 } 252 } 253 } 254 255 return 0; 256} 257 258static av_cold int dvvideo_init(AVCodecContext *avctx) 259{ 260 DVVideoContext *s = avctx->priv_data; 261 DSPContext dsp; 262 static int done = 0; 263 int i, j; 264 265 if (!done) { 266 VLC dv_vlc; 267 uint16_t new_dv_vlc_bits[NB_DV_VLC*2]; 268 uint8_t new_dv_vlc_len[NB_DV_VLC*2]; 269 uint8_t new_dv_vlc_run[NB_DV_VLC*2]; 270 int16_t new_dv_vlc_level[NB_DV_VLC*2]; 271 272 done = 1; 273 274 /* it's faster to include sign bit in a generic VLC parsing scheme */ 275 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) { 276 new_dv_vlc_bits[j] = dv_vlc_bits[i]; 277 new_dv_vlc_len[j] = dv_vlc_len[i]; 278 new_dv_vlc_run[j] = dv_vlc_run[i]; 279 new_dv_vlc_level[j] = dv_vlc_level[i]; 280 281 if (dv_vlc_level[i]) { 282 new_dv_vlc_bits[j] <<= 1; 283 new_dv_vlc_len[j]++; 284 285 j++; 286 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; 287 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; 288 new_dv_vlc_run[j] = dv_vlc_run[i]; 289 new_dv_vlc_level[j] = -dv_vlc_level[i]; 290 } 291 } 292 293 /* NOTE: as a trick, we use the fact the no codes are unused 294 to accelerate the parsing of partial codes */ 295 init_vlc(&dv_vlc, TEX_VLC_BITS, j, 296 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); 297 assert(dv_vlc.table_size == 1184); 298 299 for (i = 0; i < dv_vlc.table_size; i++){ 300 int code = dv_vlc.table[i][0]; 301 int len = dv_vlc.table[i][1]; 302 int level, run; 303 304 if (len < 0){ //more bits needed 305 run = 0; 306 level = code; 307 } else { 308 run = new_dv_vlc_run [code] + 1; 309 level = new_dv_vlc_level[code]; 310 } 311 dv_rl_vlc[i].len = len; 312 dv_rl_vlc[i].level = level; 313 dv_rl_vlc[i].run = run; 314 } 315 ff_free_vlc(&dv_vlc); 316 317 dv_vlc_map_tableinit(); 318 } 319 320 /* Generic DSP setup */ 321 dsputil_init(&dsp, avctx); 322 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp); 323 s->get_pixels = dsp.get_pixels; 324 s->ildct_cmp = dsp.ildct_cmp[5]; 325 326 /* 88DCT setup */ 327 s->fdct[0] = dsp.fdct; 328 s->idct_put[0] = dsp.idct_put; 329 for (i = 0; i < 64; i++) 330 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]]; 331 332 /* 248DCT setup */ 333 s->fdct[1] = dsp.fdct248; 334 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP 335 if (avctx->lowres){ 336 for (i = 0; i < 64; i++){ 337 int j = ff_zigzag248_direct[i]; 338 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2]; 339 } 340 }else 341 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); 342 343 avctx->coded_frame = &s->picture; 344 s->avctx = avctx; 345 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; 346 347 return 0; 348} 349 350static av_cold int dvvideo_init_encoder(AVCodecContext *avctx) 351{ 352 if (!avpriv_dv_codec_profile(avctx)) { 353 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n", 354 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt)); 355 return -1; 356 } 357 358 return dvvideo_init(avctx); 359} 360 361typedef struct BlockInfo { 362 const uint32_t *factor_table; 363 const uint8_t *scan_table; 364 uint8_t pos; /* position in block */ 365 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); 366 uint8_t partial_bit_count; 367 uint32_t partial_bit_buffer; 368 int shift_offset; 369} BlockInfo; 370 371/* bit budget for AC only in 5 MBs */ 372static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; 373static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; 374 375/* decode AC coefficients */ 376static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) 377{ 378 int last_index = gb->size_in_bits; 379 const uint8_t *scan_table = mb->scan_table; 380 const uint32_t *factor_table = mb->factor_table; 381 int pos = mb->pos; 382 int partial_bit_count = mb->partial_bit_count; 383 int level, run, vlc_len, index; 384 385 OPEN_READER(re, gb); 386 UPDATE_CACHE(re, gb); 387 388 /* if we must parse a partial VLC, we do it here */ 389 if (partial_bit_count > 0) { 390 re_cache = re_cache >> partial_bit_count | mb->partial_bit_buffer; 391 re_index -= partial_bit_count; 392 mb->partial_bit_count = 0; 393 } 394 395 /* get the AC coefficients until last_index is reached */ 396 for (;;) { 397 av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), 398 re_index); 399 /* our own optimized GET_RL_VLC */ 400 index = NEG_USR32(re_cache, TEX_VLC_BITS); 401 vlc_len = dv_rl_vlc[index].len; 402 if (vlc_len < 0) { 403 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level; 404 vlc_len = TEX_VLC_BITS - vlc_len; 405 } 406 level = dv_rl_vlc[index].level; 407 run = dv_rl_vlc[index].run; 408 409 /* gotta check if we're still within gb boundaries */ 410 if (re_index + vlc_len > last_index) { 411 /* should be < 16 bits otherwise a codeword could have been parsed */ 412 mb->partial_bit_count = last_index - re_index; 413 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count); 414 re_index = last_index; 415 break; 416 } 417 re_index += vlc_len; 418 419 av_dlog(NULL, "run=%d level=%d\n", run, level); 420 pos += run; 421 if (pos >= 64) 422 break; 423 424 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits; 425 block[scan_table[pos]] = level; 426 427 UPDATE_CACHE(re, gb); 428 } 429 CLOSE_READER(re, gb); 430 mb->pos = pos; 431} 432 433static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) 434{ 435 int bits_left = get_bits_left(gb); 436 while (bits_left >= MIN_CACHE_BITS) { 437 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); 438 bits_left -= MIN_CACHE_BITS; 439 } 440 if (bits_left > 0) { 441 put_bits(pb, bits_left, get_bits(gb, bits_left)); 442 } 443} 444 445static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y) 446{ 447 *mb_x = work_chunk->mb_coordinates[m] & 0xff; 448 *mb_y = work_chunk->mb_coordinates[m] >> 8; 449 450 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */ 451 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) { 452 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */ 453 } 454} 455 456/* mb_x and mb_y are in units of 8 pixels */ 457static int dv_decode_video_segment(AVCodecContext *avctx, void *arg) 458{ 459 DVVideoContext *s = avctx->priv_data; 460 DVwork_chunk *work_chunk = arg; 461 int quant, dc, dct_mode, class1, j; 462 int mb_index, mb_x, mb_y, last_index; 463 int y_stride, linesize; 464 DCTELEM *block, *block1; 465 int c_offset; 466 uint8_t *y_ptr; 467 const uint8_t *buf_ptr; 468 PutBitContext pb, vs_pb; 469 GetBitContext gb; 470 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1; 471 LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]); 472 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */ 473 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */ 474 const int log2_blocksize = 3-s->avctx->lowres; 475 int is_field_mode[5]; 476 477 assert((((int)mb_bit_buffer) & 7) == 0); 478 assert((((int)vs_bit_buffer) & 7) == 0); 479 480 memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock)); 481 482 /* pass 1: read DC and AC coefficients in blocks */ 483 buf_ptr = &s->buf[work_chunk->buf_offset*80]; 484 block1 = &sblock[0][0]; 485 mb1 = mb_data; 486 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); 487 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) { 488 /* skip header */ 489 quant = buf_ptr[3] & 0x0f; 490 buf_ptr += 4; 491 init_put_bits(&pb, mb_bit_buffer, 80); 492 mb = mb1; 493 block = block1; 494 is_field_mode[mb_index] = 0; 495 for (j = 0; j < s->sys->bpm; j++) { 496 last_index = s->sys->block_sizes[j]; 497 init_get_bits(&gb, buf_ptr, last_index); 498 499 /* get the DC */ 500 dc = get_sbits(&gb, 9); 501 dct_mode = get_bits1(&gb); 502 class1 = get_bits(&gb, 2); 503 if (DV_PROFILE_IS_HD(s->sys)) { 504 mb->idct_put = s->idct_put[0]; 505 mb->scan_table = s->dv_zigzag[0]; 506 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64]; 507 is_field_mode[mb_index] |= !j && dct_mode; 508 } else { 509 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3]; 510 mb->scan_table = s->dv_zigzag[dct_mode]; 511 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 + 512 (quant + dv_quant_offset[class1])*64]; 513 } 514 dc = dc << 2; 515 /* convert to unsigned because 128 is not added in the 516 standard IDCT */ 517 dc += 1024; 518 block[0] = dc; 519 buf_ptr += last_index >> 3; 520 mb->pos = 0; 521 mb->partial_bit_count = 0; 522 523 av_dlog(avctx, "MB block: %d, %d ", mb_index, j); 524 dv_decode_ac(&gb, mb, block); 525 526 /* write the remaining bits in a new buffer only if the 527 block is finished */ 528 if (mb->pos >= 64) 529 bit_copy(&pb, &gb); 530 531 block += 64; 532 mb++; 533 } 534 535 /* pass 2: we can do it just after */ 536 av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); 537 block = block1; 538 mb = mb1; 539 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); 540 put_bits32(&pb, 0); // padding must be zeroed 541 flush_put_bits(&pb); 542 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) { 543 if (mb->pos < 64 && get_bits_left(&gb) > 0) { 544 dv_decode_ac(&gb, mb, block); 545 /* if still not finished, no need to parse other blocks */ 546 if (mb->pos < 64) 547 break; 548 } 549 } 550 /* all blocks are finished, so the extra bytes can be used at 551 the video segment level */ 552 if (j >= s->sys->bpm) 553 bit_copy(&vs_pb, &gb); 554 } 555 556 /* we need a pass over the whole video segment */ 557 av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb)); 558 block = &sblock[0][0]; 559 mb = mb_data; 560 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb)); 561 put_bits32(&vs_pb, 0); // padding must be zeroed 562 flush_put_bits(&vs_pb); 563 for (mb_index = 0; mb_index < 5; mb_index++) { 564 for (j = 0; j < s->sys->bpm; j++) { 565 if (mb->pos < 64) { 566 av_dlog(avctx, "start %d:%d\n", mb_index, j); 567 dv_decode_ac(&gb, mb, block); 568 } 569 if (mb->pos >= 64 && mb->pos < 127) 570 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); 571 block += 64; 572 mb++; 573 } 574 } 575 576 /* compute idct and place blocks */ 577 block = &sblock[0][0]; 578 mb = mb_data; 579 for (mb_index = 0; mb_index < 5; mb_index++) { 580 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); 581 582 /* idct_put'ting luminance */ 583 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || 584 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || 585 (s->sys->height >= 720 && mb_y != 134)) { 586 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize)); 587 } else { 588 y_stride = (2 << log2_blocksize); 589 } 590 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize); 591 linesize = s->picture.linesize[0] << is_field_mode[mb_index]; 592 mb[0] .idct_put(y_ptr , linesize, block + 0*64); 593 if (s->sys->video_stype == 4) { /* SD 422 */ 594 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64); 595 } else { 596 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64); 597 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64); 598 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64); 599 } 600 mb += 4; 601 block += 4*64; 602 603 /* idct_put'ting chrominance */ 604 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + 605 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize); 606 for (j = 2; j; j--) { 607 uint8_t *c_ptr = s->picture.data[j] + c_offset; 608 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { 609 uint64_t aligned_pixels[64/8]; 610 uint8_t *pixels = (uint8_t*)aligned_pixels; 611 uint8_t *c_ptr1, *ptr1; 612 int x, y; 613 mb->idct_put(pixels, 8, block); 614 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) { 615 ptr1 = pixels + (1 << (log2_blocksize - 1)); 616 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize); 617 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) { 618 c_ptr[x] = pixels[x]; 619 c_ptr1[x] = ptr1[x]; 620 } 621 } 622 block += 64; mb++; 623 } else { 624 y_stride = (mb_y == 134) ? (1 << log2_blocksize) : 625 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize); 626 linesize = s->picture.linesize[j] << is_field_mode[mb_index]; 627 (mb++)-> idct_put(c_ptr , linesize, block); block += 64; 628 if (s->sys->bpm == 8) { 629 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64; 630 } 631 } 632 } 633 } 634 return 0; 635} 636 637#if CONFIG_SMALL 638/* Converts run and level (where level != 0) pair into VLC, returning bit size */ 639static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) 640{ 641 int size; 642 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { 643 *vlc = dv_vlc_map[run][level].vlc | sign; 644 size = dv_vlc_map[run][level].size; 645 } 646 else { 647 if (level < DV_VLC_MAP_LEV_SIZE) { 648 *vlc = dv_vlc_map[0][level].vlc | sign; 649 size = dv_vlc_map[0][level].size; 650 } else { 651 *vlc = 0xfe00 | (level << 1) | sign; 652 size = 16; 653 } 654 if (run) { 655 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : 656 (0x1f80 | (run - 1))) << size; 657 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; 658 } 659 } 660 661 return size; 662} 663 664static av_always_inline int dv_rl2vlc_size(int run, int level) 665{ 666 int size; 667 668 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { 669 size = dv_vlc_map[run][level].size; 670 } 671 else { 672 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; 673 if (run) { 674 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; 675 } 676 } 677 return size; 678} 679#else 680static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) 681{ 682 *vlc = dv_vlc_map[run][l].vlc | sign; 683 return dv_vlc_map[run][l].size; 684} 685 686static av_always_inline int dv_rl2vlc_size(int run, int l) 687{ 688 return dv_vlc_map[run][l].size; 689} 690#endif 691 692typedef struct EncBlockInfo { 693 int area_q[4]; 694 int bit_size[4]; 695 int prev[5]; 696 int cur_ac; 697 int cno; 698 int dct_mode; 699 DCTELEM mb[64]; 700 uint8_t next[64]; 701 uint8_t sign[64]; 702 uint8_t partial_bit_count; 703 uint32_t partial_bit_buffer; /* we can't use uint16_t here */ 704} EncBlockInfo; 705 706static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, 707 PutBitContext* pb_pool, 708 PutBitContext* pb_end) 709{ 710 int prev, bits_left; 711 PutBitContext* pb = pb_pool; 712 int size = bi->partial_bit_count; 713 uint32_t vlc = bi->partial_bit_buffer; 714 715 bi->partial_bit_count = bi->partial_bit_buffer = 0; 716 for (;;){ 717 /* Find suitable storage space */ 718 for (; size > (bits_left = put_bits_left(pb)); pb++) { 719 if (bits_left) { 720 size -= bits_left; 721 put_bits(pb, bits_left, vlc >> size); 722 vlc = vlc & ((1 << size) - 1); 723 } 724 if (pb + 1 >= pb_end) { 725 bi->partial_bit_count = size; 726 bi->partial_bit_buffer = vlc; 727 return pb; 728 } 729 } 730 731 /* Store VLC */ 732 put_bits(pb, size, vlc); 733 734 if (bi->cur_ac >= 64) 735 break; 736 737 /* Construct the next VLC */ 738 prev = bi->cur_ac; 739 bi->cur_ac = bi->next[prev]; 740 if (bi->cur_ac < 64){ 741 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); 742 } else { 743 size = 4; vlc = 6; /* End Of Block stamp */ 744 } 745 } 746 return pb; 747} 748 749static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) { 750 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) { 751 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400; 752 if (ps > 0) { 753 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) + 754 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4); 755 return ps > is; 756 } 757 } 758 759 return 0; 760} 761 762static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias) 763{ 764 const int *weight; 765 const uint8_t* zigzag_scan; 766 LOCAL_ALIGNED_16(DCTELEM, blk, [64]); 767 int i, area; 768 /* We offer two different methods for class number assignment: the 769 method suggested in SMPTE 314M Table 22, and an improved 770 method. The SMPTE method is very conservative; it assigns class 771 3 (i.e. severe quantization) to any block where the largest AC 772 component is greater than 36. Libav's DV encoder tracks AC bit 773 consumption precisely, so there is no need to bias most blocks 774 towards strongly lossy compression. Instead, we assign class 2 775 to most blocks, and use class 3 only when strictly necessary 776 (for blocks whose largest AC component exceeds 255). */ 777 778#if 0 /* SMPTE spec method */ 779 static const int classes[] = {12, 24, 36, 0xffff}; 780#else /* improved Libav method */ 781 static const int classes[] = {-1, -1, 255, 0xffff}; 782#endif 783 int max = classes[0]; 784 int prev = 0; 785 786 assert((((int)blk) & 15) == 0); 787 788 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0; 789 bi->partial_bit_count = 0; 790 bi->partial_bit_buffer = 0; 791 bi->cur_ac = 0; 792 if (data) { 793 bi->dct_mode = dv_guess_dct_mode(s, data, linesize); 794 s->get_pixels(blk, data, linesize); 795 s->fdct[bi->dct_mode](blk); 796 } else { 797 /* We rely on the fact that encoding all zeros leads to an immediate EOB, 798 which is precisely what the spec calls for in the "dummy" blocks. */ 799 memset(blk, 0, 64*sizeof(*blk)); 800 bi->dct_mode = 0; 801 } 802 bi->mb[0] = blk[0]; 803 804 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct; 805 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88; 806 807 for (area = 0; area < 4; area++) { 808 bi->prev[area] = prev; 809 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) 810 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) { 811 int level = blk[zigzag_scan[i]]; 812 813 if (level + 15 > 30U) { 814 bi->sign[i] = (level >> 31) & 1; 815 /* weight it and and shift down into range, adding for rounding */ 816 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT 817 AND the 2x doubling of the weights */ 818 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4); 819 bi->mb[i] = level; 820 if (level > max) 821 max = level; 822 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); 823 bi->next[prev]= i; 824 prev = i; 825 } 826 } 827 } 828 bi->next[prev]= i; 829 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++); 830 831 bi->cno += bias; 832 833 if (bi->cno >= 3) { 834 bi->cno = 3; 835 prev = 0; 836 i = bi->next[prev]; 837 for (area = 0; area < 4; area++) { 838 bi->prev[area] = prev; 839 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) 840 for (; i < mb_area_start[area+1]; i = bi->next[i]) { 841 bi->mb[i] >>= 1; 842 843 if (bi->mb[i]) { 844 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); 845 bi->next[prev]= i; 846 prev = i; 847 } 848 } 849 } 850 bi->next[prev]= i; 851 } 852 853 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3]; 854} 855 856static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) 857{ 858 int size[5]; 859 int i, j, k, a, prev, a2; 860 EncBlockInfo* b; 861 862 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24; 863 do { 864 b = blks; 865 for (i = 0; i < 5; i++) { 866 if (!qnos[i]) 867 continue; 868 869 qnos[i]--; 870 size[i] = 0; 871 for (j = 0; j < 6; j++, b++) { 872 for (a = 0; a < 4; a++) { 873 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { 874 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) 875 b->area_q[a]++; 876 prev = b->prev[a]; 877 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); 878 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) { 879 b->mb[k] >>= 1; 880 if (b->mb[k]) { 881 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); 882 prev = k; 883 } else { 884 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){ 885 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++) 886 b->prev[a2] = prev; 887 assert(a2 < 4); 888 assert(b->mb[b->next[k]]); 889 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) 890 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); 891 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k)); 892 b->prev[a2] = prev; 893 } 894 b->next[prev] = b->next[k]; 895 } 896 } 897 b->prev[a+1]= prev; 898 } 899 size[i] += b->bit_size[a]; 900 } 901 } 902 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) 903 return; 904 } 905 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); 906 907 908 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){ 909 b = blks; 910 size[0] = 5 * 6 * 4; //EOB 911 for (j = 0; j < 6 *5; j++, b++) { 912 prev = b->prev[0]; 913 for (k = b->next[prev]; k < 64; k = b->next[k]) { 914 if (b->mb[k] < a && b->mb[k] > -a){ 915 b->next[prev] = b->next[k]; 916 }else{ 917 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); 918 prev = k; 919 } 920 } 921 } 922 } 923} 924 925static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) 926{ 927 DVVideoContext *s = avctx->priv_data; 928 DVwork_chunk *work_chunk = arg; 929 int mb_index, i, j; 930 int mb_x, mb_y, c_offset, linesize, y_stride; 931 uint8_t* y_ptr; 932 uint8_t* dif; 933 LOCAL_ALIGNED_8(uint8_t, scratch, [64]); 934 EncBlockInfo enc_blks[5*DV_MAX_BPM]; 935 PutBitContext pbs[5*DV_MAX_BPM]; 936 PutBitContext* pb; 937 EncBlockInfo* enc_blk; 938 int vs_bit_size = 0; 939 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */ 940 int* qnosp = &qnos[0]; 941 942 dif = &s->buf[work_chunk->buf_offset*80]; 943 enc_blk = &enc_blks[0]; 944 for (mb_index = 0; mb_index < 5; mb_index++) { 945 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); 946 947 /* initializing luminance blocks */ 948 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || 949 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || 950 (s->sys->height >= 720 && mb_y != 134)) { 951 y_stride = s->picture.linesize[0] << 3; 952 } else { 953 y_stride = 16; 954 } 955 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3); 956 linesize = s->picture.linesize[0]; 957 958 if (s->sys->video_stype == 4) { /* SD 422 */ 959 vs_bit_size += 960 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + 961 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) + 962 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) + 963 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0); 964 } else { 965 vs_bit_size += 966 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + 967 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) + 968 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) + 969 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0); 970 } 971 enc_blk += 4; 972 973 /* initializing chrominance blocks */ 974 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + 975 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3); 976 for (j = 2; j; j--) { 977 uint8_t *c_ptr = s->picture.data[j] + c_offset; 978 linesize = s->picture.linesize[j]; 979 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3); 980 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { 981 uint8_t* d; 982 uint8_t* b = scratch; 983 for (i = 0; i < 8; i++) { 984 d = c_ptr + (linesize << 3); 985 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3]; 986 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; 987 c_ptr += linesize; 988 b += 8; 989 } 990 c_ptr = scratch; 991 linesize = 8; 992 } 993 994 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1); 995 if (s->sys->bpm == 8) { 996 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1); 997 } 998 } 999 } 1000 1001 if (vs_total_ac_bits < vs_bit_size) 1002 dv_guess_qnos(&enc_blks[0], qnosp); 1003 1004 /* DIF encoding process */ 1005 for (j=0; j<5*s->sys->bpm;) { 1006 int start_mb = j; 1007 1008 dif[3] = *qnosp++; 1009 dif += 4; 1010 1011 /* First pass over individual cells only */ 1012 for (i=0; i<s->sys->bpm; i++, j++) { 1013 int sz = s->sys->block_sizes[i]>>3; 1014 1015 init_put_bits(&pbs[j], dif, sz); 1016 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2); 1017 put_bits(&pbs[j], 1, enc_blks[j].dct_mode); 1018 put_bits(&pbs[j], 2, enc_blks[j].cno); 1019 1020 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); 1021 dif += sz; 1022 } 1023 1024 /* Second pass over each MB space */ 1025 pb = &pbs[start_mb]; 1026 for (i=0; i<s->sys->bpm; i++) { 1027 if (enc_blks[start_mb+i].partial_bit_count) 1028 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]); 1029 } 1030 } 1031 1032 /* Third and final pass over the whole video segment space */ 1033 pb = &pbs[0]; 1034 for (j=0; j<5*s->sys->bpm; j++) { 1035 if (enc_blks[j].partial_bit_count) 1036 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]); 1037 if (enc_blks[j].partial_bit_count) 1038 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n"); 1039 } 1040 1041 for (j=0; j<5*s->sys->bpm; j++) { 1042 int pos; 1043 int size = pbs[j].size_in_bits >> 3; 1044 flush_put_bits(&pbs[j]); 1045 pos = put_bits_count(&pbs[j]) >> 3; 1046 if (pos > size) { 1047 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n"); 1048 return -1; 1049 } 1050 memset(pbs[j].buf + pos, 0xff, size - pos); 1051 } 1052 1053 return 0; 1054} 1055 1056#if CONFIG_DVVIDEO_DECODER 1057/* NOTE: exactly one frame must be given (120000 bytes for NTSC, 1058 144000 bytes for PAL - or twice those for 50Mbps) */ 1059static int dvvideo_decode_frame(AVCodecContext *avctx, 1060 void *data, int *data_size, 1061 AVPacket *avpkt) 1062{ 1063 const uint8_t *buf = avpkt->data; 1064 int buf_size = avpkt->size; 1065 DVVideoContext *s = avctx->priv_data; 1066 const uint8_t* vsc_pack; 1067 int apt, is16_9; 1068 1069 s->sys = avpriv_dv_frame_profile(s->sys, buf, buf_size); 1070 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) { 1071 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n"); 1072 return -1; /* NOTE: we only accept several full frames */ 1073 } 1074 1075 if (s->picture.data[0]) 1076 avctx->release_buffer(avctx, &s->picture); 1077 1078 s->picture.reference = 0; 1079 s->picture.key_frame = 1; 1080 s->picture.pict_type = AV_PICTURE_TYPE_I; 1081 avctx->pix_fmt = s->sys->pix_fmt; 1082 avctx->time_base = s->sys->time_base; 1083 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height); 1084 if (avctx->get_buffer(avctx, &s->picture) < 0) { 1085 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 1086 return -1; 1087 } 1088 s->picture.interlaced_frame = 1; 1089 s->picture.top_field_first = 0; 1090 1091 s->buf = buf; 1092 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL, 1093 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); 1094 1095 emms_c(); 1096 1097 /* return image */ 1098 *data_size = sizeof(AVFrame); 1099 *(AVFrame*)data = s->picture; 1100 1101 /* Determine the codec's sample_aspect ratio from the packet */ 1102 vsc_pack = buf + 80*5 + 48 + 5; 1103 if ( *vsc_pack == dv_video_control ) { 1104 apt = buf[4] & 0x07; 1105 is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07))); 1106 avctx->sample_aspect_ratio = s->sys->sar[is16_9]; 1107 } 1108 1109 return s->sys->frame_size; 1110} 1111#endif /* CONFIG_DVVIDEO_DECODER */ 1112 1113 1114static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, 1115 uint8_t* buf) 1116{ 1117 /* 1118 * Here's what SMPTE314M says about these two: 1119 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical 1120 * as track application IDs (APTn = 001, AP1n = 1121 * 001, AP2n = 001, AP3n = 001), if the source signal 1122 * comes from a digital VCR. If the signal source is 1123 * unknown, all bits for these data shall be set to 1. 1124 * (page 12) STYPE: STYPE defines a signal type of video signal 1125 * 00000b = 4:1:1 compression 1126 * 00100b = 4:2:2 compression 1127 * XXXXXX = Reserved 1128 * Now, I've got two problems with these statements: 1129 * 1. it looks like APT == 111b should be a safe bet, but it isn't. 1130 * It seems that for PAL as defined in IEC 61834 we have to set 1131 * APT to 000 and for SMPTE314M to 001. 1132 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL 1133 * compression scheme (if any). 1134 */ 1135 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1); 1136 1137 uint8_t aspect = 0; 1138 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */ 1139 aspect = 0x02; 1140 1141 buf[0] = (uint8_t)pack_id; 1142 switch (pack_id) { 1143 case dv_header525: /* I can't imagine why these two weren't defined as real */ 1144 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */ 1145 buf[1] = 0xf8 | /* reserved -- always 1 */ 1146 (apt & 0x07); /* APT: Track application ID */ 1147 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */ 1148 (0x0f << 3) | /* reserved -- always 1 */ 1149 (apt & 0x07); /* AP1: Audio application ID */ 1150 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */ 1151 (0x0f << 3) | /* reserved -- always 1 */ 1152 (apt & 0x07); /* AP2: Video application ID */ 1153 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */ 1154 (0x0f << 3) | /* reserved -- always 1 */ 1155 (apt & 0x07); /* AP3: Subcode application ID */ 1156 break; 1157 case dv_video_source: 1158 buf[1] = 0xff; /* reserved -- always 1 */ 1159 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */ 1160 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */ 1161 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */ 1162 0xf; /* reserved -- always 1 */ 1163 buf[3] = (3 << 6) | /* reserved -- always 1 */ 1164 (c->sys->dsf << 5) | /* system: 60fields/50fields */ 1165 c->sys->video_stype; /* signal type video compression */ 1166 buf[4] = 0xff; /* VISC: 0xff -- no information */ 1167 break; 1168 case dv_video_control: 1169 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */ 1170 0x3f; /* reserved -- always 1 */ 1171 buf[2] = 0xc8 | /* reserved -- always b11001xxx */ 1172 aspect; 1173 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */ 1174 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */ 1175 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */ 1176 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */ 1177 0xc; /* reserved -- always b1100 */ 1178 buf[4] = 0xff; /* reserved -- always 1 */ 1179 break; 1180 default: 1181 buf[1] = buf[2] = buf[3] = buf[4] = 0xff; 1182 } 1183 return 5; 1184} 1185 1186#if CONFIG_DVVIDEO_ENCODER 1187static void dv_format_frame(DVVideoContext* c, uint8_t* buf) 1188{ 1189 int chan, i, j, k; 1190 1191 for (chan = 0; chan < c->sys->n_difchan; chan++) { 1192 for (i = 0; i < c->sys->difseg_size; i++) { 1193 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */ 1194 1195 /* DV header: 1DIF */ 1196 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf); 1197 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf); 1198 buf += 72; /* unused bytes */ 1199 1200 /* DV subcode: 2DIFs */ 1201 for (j = 0; j < 2; j++) { 1202 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf); 1203 for (k = 0; k < 6; k++) 1204 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5; 1205 buf += 29; /* unused bytes */ 1206 } 1207 1208 /* DV VAUX: 3DIFS */ 1209 for (j = 0; j < 3; j++) { 1210 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf); 1211 buf += dv_write_pack(dv_video_source, c, buf); 1212 buf += dv_write_pack(dv_video_control, c, buf); 1213 buf += 7*5; 1214 buf += dv_write_pack(dv_video_source, c, buf); 1215 buf += dv_write_pack(dv_video_control, c, buf); 1216 buf += 4*5 + 2; /* unused bytes */ 1217 } 1218 1219 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */ 1220 for (j = 0; j < 135; j++) { 1221 if (j%15 == 0) { 1222 memset(buf, 0xff, 80); 1223 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf); 1224 buf += 77; /* audio control & shuffled PCM audio */ 1225 } 1226 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf); 1227 buf += 77; /* 1 video macroblock: 1 bytes control 1228 4 * 14 bytes Y 8x8 data 1229 10 bytes Cr 8x8 data 1230 10 bytes Cb 8x8 data */ 1231 } 1232 } 1233 } 1234} 1235 1236 1237static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, 1238 void *data) 1239{ 1240 DVVideoContext *s = c->priv_data; 1241 1242 s->sys = avpriv_dv_codec_profile(c); 1243 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) 1244 return -1; 1245 1246 c->pix_fmt = s->sys->pix_fmt; 1247 s->picture = *((AVFrame *)data); 1248 s->picture.key_frame = 1; 1249 s->picture.pict_type = AV_PICTURE_TYPE_I; 1250 1251 s->buf = buf; 1252 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL, 1253 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); 1254 1255 emms_c(); 1256 1257 dv_format_frame(s, buf); 1258 1259 return s->sys->frame_size; 1260} 1261#endif 1262 1263static int dvvideo_close(AVCodecContext *c) 1264{ 1265 DVVideoContext *s = c->priv_data; 1266 1267 if (s->picture.data[0]) 1268 c->release_buffer(c, &s->picture); 1269 1270 return 0; 1271} 1272 1273 1274#if CONFIG_DVVIDEO_ENCODER 1275AVCodec ff_dvvideo_encoder = { 1276 .name = "dvvideo", 1277 .type = AVMEDIA_TYPE_VIDEO, 1278 .id = CODEC_ID_DVVIDEO, 1279 .priv_data_size = sizeof(DVVideoContext), 1280 .init = dvvideo_init_encoder, 1281 .encode = dvvideo_encode_frame, 1282 .capabilities = CODEC_CAP_SLICE_THREADS, 1283 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE}, 1284 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), 1285}; 1286#endif // CONFIG_DVVIDEO_ENCODER 1287 1288#if CONFIG_DVVIDEO_DECODER 1289AVCodec ff_dvvideo_decoder = { 1290 .name = "dvvideo", 1291 .type = AVMEDIA_TYPE_VIDEO, 1292 .id = CODEC_ID_DVVIDEO, 1293 .priv_data_size = sizeof(DVVideoContext), 1294 .init = dvvideo_init, 1295 .close = dvvideo_close, 1296 .decode = dvvideo_decode_frame, 1297 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS, 1298 .max_lowres = 3, 1299 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), 1300}; 1301#endif 1302