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