comparison dv.c @ 7715:e8f71784062e libavcodec

Intial implementation of the DV100 (AKA DVCPRO HD) decoder and demuxer as specified in SMPTE 370M

7714:f0f8bb920b24

 * DV encoder
 * Copyright (c) 2003 Roman Shaposhnik.
 *
 * 50 Mbps (DVCPRO50) support
 * Copyright (c) 2006 Daniel Maas <[e-mail]>
 *
 * Many thanks to Dan Dennedy <[e-mail]> for providing wealth
 * of DV technical info.
 *
 * This file is part of FFmpeg.

    AVCodecContext *avctx;
    uint8_t *buf;

    uint8_t dv_zigzag[2][64];
    uint32_t dv_idct_factor[2][2][22][64];

    void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
    void (*fdct[2])(DCTELEM *block);
    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
} DVVideoContext;

/* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
/* one element is needed for each video segment in a DV frame */
/* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */
#define DV_ANCHOR_SIZE (2*12*27)

static void* dv_anchor[DV_ANCHOR_SIZE];

#define TEX_VLC_BITS 9

                s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i]<<1;

                /* 248 table */
                s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i]<<(dv_quant_shifts[q][a] + 1);
                s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i]<<1;
            }
        }
    }
}

                                           const uint8_t *buf_ptr1,
                                           const uint16_t *mb_pos_ptr)
{
    int quant, dc, dct_mode, class1, j;
    int mb_index, mb_x, mb_y, v, last_index;
    DCTELEM *block, *block1;
    int c_offset;
    uint8_t *y_ptr;
    const uint8_t *buf_ptr;
    PutBitContext pb, vs_pb;

    BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
    DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
    DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
    DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
    const int log2_blocksize= 3-s->avctx->lowres;

    assert((((int)mb_bit_buffer)&7)==0);
    assert((((int)vs_bit_buffer)&7)==0);

    memset(sblock, 0, sizeof(sblock));

        quant = buf_ptr[3] & 0x0f;
        buf_ptr += 4;
        init_put_bits(&pb, mb_bit_buffer, 80);
        mb = mb1;
        block = block1;
        for(j = 0;j < s->sys->bpm; j++) {
            last_index = s->sys->block_sizes[j];
            init_get_bits(&gb, buf_ptr, last_index);

            /* get the dc */
            dc = get_sbits(&gb, 9);
            dct_mode = get_bits1(&gb);
            class1 = get_bits(&gb, 2);
            mb->idct_put = s->idct_put[dct_mode && log2_blocksize==3];
            mb->scan_table = s->dv_zigzag[dct_mode];
            mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
                [quant + dv_quant_offset[class1]];
            dc = dc << 2;
            /* convert to unsigned because 128 is not added in the
               standard IDCT */
            dc += 1024;
            block[0] = dc;

    mb = mb_data;
    for(mb_index = 0; mb_index < 5; mb_index++) {
        v = *mb_pos_ptr++;
        mb_x = v & 0xff;
        mb_y = v >> 8;
        y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
        c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
                     (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<log2_blocksize);

        for(j = 0;j < 6; j++) {
            if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
                if (j == 0 || j == 2) {
                    /* Y0 Y1 */
                    mb->idct_put(y_ptr + ((j >> 1)<<log2_blocksize),
                             s->picture.linesize[0], block);
                } else if(j > 3) {
                    /* Cr Cb */
                    mb->idct_put(s->picture.data[6 - j] + c_offset,
                             s->picture.linesize[6 - j], block);
                }
                /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */
            } else { /* 4:1:1 or 4:2:0 */
                if (j < 4) {
                    if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
                        /* NOTE: at end of line, the macroblock is handled as 420 */
                        mb->idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
                    } else {
                        mb->idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
                                 s->picture.linesize[0], block);
                    }
                } else {
                    if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
                        uint64_t aligned_pixels[64/8];
                        uint8_t *pixels= (uint8_t*)aligned_pixels;
                        uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
                        int x, y, linesize;
                        /* NOTE: at end of line, the macroblock is handled as 420 */
                        mb->idct_put(pixels, 8, block);
                        linesize = s->picture.linesize[6 - j];
                        c_ptr = s->picture.data[6 - j] + c_offset;
                        ptr = pixels;
                        for(y = 0;y < (1<<log2_blocksize); y++) {
                            ptr1= ptr + (1<<(log2_blocksize-1));
                            c_ptr1 = c_ptr + (linesize<<log2_blocksize);
                            for(x=0; x < (1<<(log2_blocksize-1)); x++){
                                c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
                            }
                            c_ptr += linesize;
                            ptr += 8;
                        }
                    } else {
                        /* don't ask me why they inverted Cb and Cr ! */
                        mb->idct_put(s->picture.data[6 - j] + c_offset,
                                 s->picture.linesize[6 - j], block);
                    }
                }
            }
            block += 64;
            mb++;
        }
    }
}

#ifdef DV_CODEC_TINY_TARGET

    int chan_offset = chan * s->sys->difseg_size * 150 * 80;

    /* DIF sequence */
    int seq = chan_slice / 27;

    dv_decode_video_segment(s, &s->buf[(seq*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
                            &s->sys->video_place[slice*5]);
    return 0;
}

7715:e8f71784062e

 * DV encoder
 * Copyright (c) 2003 Roman Shaposhnik.
 *
 * 50 Mbps (DVCPRO50) support
 * Copyright (c) 2006 Daniel Maas <[e-mail]>
 *
 * 100 Mbps (DVCPRO HD) support
 * Initial code by Daniel Maas <[e-mail]> (funded by BBC R&D)
 * Final code by Roman Shaposhnik
 *
 * Many thanks to Dan Dennedy <[e-mail]> for providing wealth
 * of DV technical info.
 *
 * This file is part of FFmpeg.

    AVCodecContext *avctx;
    uint8_t *buf;

    uint8_t dv_zigzag[2][64];
    uint32_t dv_idct_factor[2][2][22][64];
    uint32_t dv100_idct_factor[4][4][16][64];

    void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
    void (*fdct[2])(DCTELEM *block);
    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
} DVVideoContext;

/* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
/* one element is needed for each video segment in a DV frame */
/* at most there are 4 DIF channels * 12 DIF sequences * 27 video segments (1080i50) */
#define DV_ANCHOR_SIZE (4*12*27)

static void* dv_anchor[DV_ANCHOR_SIZE];

#define TEX_VLC_BITS 9

                s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i]<<1;

                /* 248 table */
                s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i]<<(dv_quant_shifts[q][a] + 1);
                s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i]<<1;
            }
        }
    }

    for(a = 0; a < 4; a++) {
        for(q = 0; q < 16; q++) {
            for(i = 1; i < 64; i++) {
                s->dv100_idct_factor[0][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_y[i];
                s->dv100_idct_factor[1][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_c[i];
                s->dv100_idct_factor[2][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_y[i];
                s->dv100_idct_factor[3][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_c[i];
            }
        }
    }
}

                                           const uint8_t *buf_ptr1,
                                           const uint16_t *mb_pos_ptr)
{
    int quant, dc, dct_mode, class1, j;
    int mb_index, mb_x, mb_y, v, last_index;
    int y_stride, i;
    DCTELEM *block, *block1;
    int c_offset;
    uint8_t *y_ptr;
    const uint8_t *buf_ptr;
    PutBitContext pb, vs_pb;

    BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
    DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
    DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
    DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
    const int log2_blocksize= 3-s->avctx->lowres;
    int is_field_mode[5];

    assert((((int)mb_bit_buffer)&7)==0);
    assert((((int)vs_bit_buffer)&7)==0);

    memset(sblock, 0, sizeof(sblock));

        quant = buf_ptr[3] & 0x0f;
        buf_ptr += 4;
        init_put_bits(&pb, mb_bit_buffer, 80);
        mb = mb1;
        block = block1;
        is_field_mode[mb_index] = 0;
        for(j = 0;j < s->sys->bpm; j++) {
            last_index = s->sys->block_sizes[j];
            init_get_bits(&gb, buf_ptr, last_index);

            /* get the dc */
            dc = get_sbits(&gb, 9);
            dct_mode = get_bits1(&gb);
            class1 = get_bits(&gb, 2);
            if (DV_PROFILE_IS_HD(s->sys)) {
                mb->idct_put = s->idct_put[0];
                mb->scan_table = s->dv_zigzag[0];
                mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720)<<1)&(j < 4)][class1][quant];
                is_field_mode[mb_index] |= !j && dct_mode;
            } else {
                mb->idct_put = s->idct_put[dct_mode && log2_blocksize==3];
                mb->scan_table = s->dv_zigzag[dct_mode];
                mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
                    [quant + dv_quant_offset[class1]];
            }
            dc = dc << 2;
            /* convert to unsigned because 128 is not added in the
               standard IDCT */
            dc += 1024;
            block[0] = dc;

    mb = mb_data;
    for(mb_index = 0; mb_index < 5; mb_index++) {
        v = *mb_pos_ptr++;
        mb_x = v & 0xff;
        mb_y = v >> 8;
        /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
        if (s->sys->height == 720 && ((s->buf[1]>>2)&0x3) == 0) {
               mb_y -= (mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
        }

        /* idct_put'ting luminance */
        if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
            (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
            (s->sys->height >= 720 && mb_y != 134)) {
            y_stride = (s->picture.linesize[0]<<((!is_field_mode[mb_index])*log2_blocksize)) - (2<<log2_blocksize);
        } else {
            y_stride = 0;
        }
        y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
        for(j = 0; j < 2; j++, y_ptr += y_stride) {
            for (i=0; i<2; i++, block += 64, mb++, y_ptr += (1<<log2_blocksize))
                 if (s->sys->pix_fmt == PIX_FMT_YUV422P && s->sys->width == 720 && i)
                     y_ptr -= (1<<log2_blocksize);
                 else
                     mb->idct_put(y_ptr, s->picture.linesize[0]<<is_field_mode[mb_index], block);
        }

        /* idct_put'ting chrominance */
        c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
                     (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<log2_blocksize);
        for(j=2; j; j--) {
            uint8_t *c_ptr = s->picture.data[j] + c_offset;
            if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
                  uint64_t aligned_pixels[64/8];
                  uint8_t *pixels = (uint8_t*)aligned_pixels;
                  uint8_t *c_ptr1, *ptr1;
                  int x, y;
                  mb->idct_put(pixels, 8, block);
                  for(y = 0; y < (1<<log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
                      ptr1= pixels + (1<<(log2_blocksize-1));
                      c_ptr1 = c_ptr + (s->picture.linesize[j]<<log2_blocksize);
                      for(x=0; x < (1<<(log2_blocksize-1)); x++) {
                          c_ptr[x]= pixels[x];
                          c_ptr1[x]= ptr1[x];
                      }
                  }
                  block += 64; mb++;
            } else {
                  y_stride = (mb_y == 134) ? (1<<log2_blocksize) :
                                             s->picture.linesize[j]<<((!is_field_mode[mb_index])*log2_blocksize);
                  for (i=0; i<(1<<(s->sys->bpm==8)); i++, block += 64, mb++, c_ptr += y_stride)
                       mb->idct_put(c_ptr, s->picture.linesize[j]<<is_field_mode[mb_index], block);
            }
        }
    }
}

#ifdef DV_CODEC_TINY_TARGET

    int chan_offset = chan * s->sys->difseg_size * 150 * 80;

    /* DIF sequence */
    int seq = chan_slice / 27;

    /* in 1080i50 and 720p50 some seq are unused */
    if ((DV_PROFILE_IS_1080i50(s->sys) && chan != 0 && seq == 11) ||
        (DV_PROFILE_IS_720p50(s->sys) && seq > 9))
        return 0;

    dv_decode_video_segment(s, &s->buf[(seq*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
                            &s->sys->video_place[slice*5]);
    return 0;
}