git.sesse.net Git - ffmpeg/blob - libavcodec/dv.c

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