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