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