imgconvert.c

mpeg4 video codec mpeg4 video codec

 pix_fmt_info[PIX_FMT_YUVJ420P].color_type = FF_COLOR_YUV_JPEG;
 pix_fmt_info[PIX_FMT_YUVJ420P].pixel_type = FF_PIXEL_PLANAR;
 pix_fmt_info[PIX_FMT_YUVJ420P].depth = 8;
 pix_fmt_info[PIX_FMT_YUVJ420P].x_chroma_shift = 1;  
 pix_fmt_info[PIX_FMT_YUVJ420P].y_chroma_shift = 1;

 pix_fmt_info[PIX_FMT_YUVJ422P].name = "yuvj422p";
 pix_fmt_info[PIX_FMT_YUVJ422P].nb_channels = 3;
 pix_fmt_info[PIX_FMT_YUVJ422P].color_type = FF_COLOR_YUV_JPEG;
 pix_fmt_info[PIX_FMT_YUVJ422P].pixel_type = FF_PIXEL_PLANAR;
 pix_fmt_info[PIX_FMT_YUVJ422P].depth = 8;
 pix_fmt_info[PIX_FMT_YUVJ422P].x_chroma_shift = 1;
 pix_fmt_info[PIX_FMT_YUVJ422P].y_chroma_shift = 0; 

 pix_fmt_info[PIX_FMT_YUVJ444P].name = "yuvj444p";
 pix_fmt_info[PIX_FMT_YUVJ444P].nb_channels = 3;
 pix_fmt_info[PIX_FMT_YUVJ444P].color_type = FF_COLOR_YUV_JPEG;
 pix_fmt_info[PIX_FMT_YUVJ444P].pixel_type = FF_PIXEL_PLANAR;
 pix_fmt_info[PIX_FMT_YUVJ444P].depth = 8;
 pix_fmt_info[PIX_FMT_YUVJ444P].x_chroma_shift = 0;
 pix_fmt_info[PIX_FMT_YUVJ444P].y_chroma_shift = 0;

 /* RGB formats */
 pix_fmt_info[PIX_FMT_RGB24].name = "rgb24";
 pix_fmt_info[PIX_FMT_RGB24].nb_channels = 3;
 pix_fmt_info[PIX_FMT_RGB24].color_type = FF_COLOR_RGB;
 pix_fmt_info[PIX_FMT_RGB24].pixel_type = FF_PIXEL_PACKED;
 pix_fmt_info[PIX_FMT_RGB24].depth = 8;
 pix_fmt_info[PIX_FMT_RGB24].x_chroma_shift = 0;
 pix_fmt_info[PIX_FMT_RGB24].y_chroma_shift = 0;

 pix_fmt_info[PIX_FMT_BGR24].name = "bgr24";
 pix_fmt_info[PIX_FMT_BGR24].nb_channels = 3;
 pix_fmt_info[PIX_FMT_BGR24].color_type = FF_COLOR_RGB;
 pix_fmt_info[PIX_FMT_BGR24].pixel_type = FF_PIXEL_PACKED;
 pix_fmt_info[PIX_FMT_BGR24].depth = 8;
 pix_fmt_info[PIX_FMT_BGR24].x_chroma_shift = 0;
 pix_fmt_info[PIX_FMT_BGR24].y_chroma_shift = 0;

 pix_fmt_info[PIX_FMT_RGBA32].name = "rgba32";
 pix_fmt_info[PIX_FMT_RGBA32].nb_channels = 4;
 pix_fmt_info[PIX_FMT_RGBA32].is_alpha = 1;
 pix_fmt_info[PIX_FMT_RGBA32].color_type = FF_COLOR_RGB;
 pix_fmt_info[PIX_FMT_RGBA32].pixel_type = FF_PIXEL_PACKED;
 pix_fmt_info[PIX_FMT_RGBA32].depth = 8;
 pix_fmt_info[PIX_FMT_RGBA32].x_chroma_shift = 0;
 pix_fmt_info[PIX_FMT_RGBA32].y_chroma_shift = 0;

 pix_fmt_info[PIX_FMT_RGB565].name = "rgb565";
 pix_fmt_info[PIX_FMT_RGB565].nb_channels = 3;
 pix_fmt_info[PIX_FMT_RGB565].color_type = FF_COLOR_RGB;
 pix_fmt_info[PIX_FMT_RGB565].pixel_type = FF_PIXEL_PACKED;
 pix_fmt_info[PIX_FMT_RGB565].depth = 5;
 pix_fmt_info[PIX_FMT_RGB565].x_chroma_shift = 0;
 pix_fmt_info[PIX_FMT_RGB565].y_chroma_shift = 0;

 pix_fmt_info[PIX_FMT_RGB555].name = "rgb555";
 pix_fmt_info[PIX_FMT_RGB555].nb_channels = 4;
 pix_fmt_info[PIX_FMT_RGB555].is_alpha = 1;
 pix_fmt_info[PIX_FMT_RGB555].color_type = FF_COLOR_RGB;
 pix_fmt_info[PIX_FMT_RGB555].pixel_type = FF_PIXEL_PACKED;
 pix_fmt_info[PIX_FMT_RGB555].depth = 5;
 pix_fmt_info[PIX_FMT_RGB555].x_chroma_shift = 0;
 pix_fmt_info[PIX_FMT_RGB555].y_chroma_shift = 0;
 
 /* gray / mono formats */
 pix_fmt_info[PIX_FMT_GRAY8].name = "gray";
 pix_fmt_info[PIX_FMT_GRAY8].nb_channels = 1;
 pix_fmt_info[PIX_FMT_GRAY8].color_type = FF_COLOR_GRAY;
 pix_fmt_info[PIX_FMT_GRAY8].pixel_type = FF_PIXEL_PLANAR;
 pix_fmt_info[PIX_FMT_GRAY8].depth = 8;

 pix_fmt_info[PIX_FMT_MONOWHITE].name = "monow";
 pix_fmt_info[PIX_FMT_MONOWHITE].nb_channels = 1;
 pix_fmt_info[PIX_FMT_MONOWHITE].color_type = FF_COLOR_GRAY;
 pix_fmt_info[PIX_FMT_MONOWHITE].pixel_type = FF_PIXEL_PLANAR;
 pix_fmt_info[PIX_FMT_MONOWHITE].depth = 1;

 pix_fmt_info[PIX_FMT_MONOBLACK].name = "monob";
 pix_fmt_info[PIX_FMT_MONOBLACK].nb_channels = 1;
 pix_fmt_info[PIX_FMT_MONOBLACK].color_type = FF_COLOR_GRAY;
 pix_fmt_info[PIX_FMT_MONOBLACK].pixel_type = FF_PIXEL_PLANAR;
 pix_fmt_info[PIX_FMT_MONOBLACK].depth = 1;

 /* paletted formats */
 pix_fmt_info[PIX_FMT_PAL8].name = "pal8";
 pix_fmt_info[PIX_FMT_PAL8].nb_channels = 4; 
 pix_fmt_info[PIX_FMT_PAL8].is_alpha = 1;
 pix_fmt_info[PIX_FMT_PAL8].color_type = FF_COLOR_RGB;
 pix_fmt_info[PIX_FMT_PAL8].pixel_type = FF_PIXEL_PALETTE;
 pix_fmt_info[PIX_FMT_PAL8].depth = 8;

 pix_fmt_info[PIX_FMT_UYVY411].name = "uyvy411";
 pix_fmt_info[PIX_FMT_UYVY411].nb_channels = 1;
 pix_fmt_info[PIX_FMT_UYVY411].color_type = FF_COLOR_YUV;
 pix_fmt_info[PIX_FMT_UYVY411].pixel_type = FF_PIXEL_PACKED;
 pix_fmt_info[PIX_FMT_UYVY411].depth = 8;
 pix_fmt_info[PIX_FMT_UYVY411].x_chroma_shift = 2;
 pix_fmt_info[PIX_FMT_UYVY411].y_chroma_shift = 0;
}
#endif

/* Picture field are filled with 'ptr' addresses. Also return size */
int avpicture_fill(AVPicture *picture, uint8_t *ptr,
		   int pix_fmt, int width, int height)
{
    int size, w2, h2, size2;
    PixFmtInfo *pinfo;
    
    if(avcodec_check_dimensions(NULL, width, height))
        goto fail;

    pinfo = &pix_fmt_info[pix_fmt];
    size = width * height;
    switch(pix_fmt) {
    case PIX_FMT_YUV420P:
    case PIX_FMT_YUV422P:
    case PIX_FMT_YUV444P:
    case PIX_FMT_YUV410P:
    case PIX_FMT_YUV411P:
    case PIX_FMT_YUVJ420P:
    case PIX_FMT_YUVJ422P:
    case PIX_FMT_YUVJ444P:
        w2 = (width + (1 << pinfo->x_chroma_shift) - 1) >> pinfo->x_chroma_shift;
        h2 = (height + (1 << pinfo->y_chroma_shift) - 1) >> pinfo->y_chroma_shift;
        size2 = w2 * h2;
        picture->data[0] = ptr;
        picture->data[1] = picture->data[0] + size;
        picture->data[2] = picture->data[1] + size2;
        picture->linesize[0] = width;
        picture->linesize[1] = w2;
        picture->linesize[2] = w2;
        return size + 2 * size2;
    case PIX_FMT_RGB24:
    case PIX_FMT_BGR24:
        picture->data[0] = ptr;
        picture->data[1] = NULL;
        picture->data[2] = NULL;
        picture->linesize[0] = width * 3;
        return size * 3;
    case PIX_FMT_RGBA32:
        picture->data[0] = ptr;
        picture->data[1] = NULL;
        picture->data[2] = NULL;
        picture->linesize[0] = width * 4;
        return size * 4;
    case PIX_FMT_RGB555:
    case PIX_FMT_RGB565:
    case PIX_FMT_YUV422:
        picture->data[0] = ptr;
        picture->data[1] = NULL;
        picture->data[2] = NULL;
        picture->linesize[0] = width * 2;
        return size * 2;
    case PIX_FMT_UYVY422:
        picture->data[0] = ptr;
        picture->data[1] = NULL;
        picture->data[2] = NULL;
        picture->linesize[0] = width * 2;
        return size * 2;
    case PIX_FMT_UYVY411:
        picture->data[0] = ptr;
        picture->data[1] = NULL;
        picture->data[2] = NULL;
        picture->linesize[0] = width + width/2;
        return size + size/2;
    case PIX_FMT_GRAY8:
        picture->data[0] = ptr;
        picture->data[1] = NULL;
        picture->data[2] = NULL;
        picture->linesize[0] = width;
        return size;
    case PIX_FMT_MONOWHITE:
    case PIX_FMT_MONOBLACK:
        picture->data[0] = ptr;
        picture->data[1] = NULL;
        picture->data[2] = NULL;
        picture->linesize[0] = (width + 7) >> 3;
        return picture->linesize[0] * height;
    case PIX_FMT_PAL8:
        size2 = (size + 3) & ~3;
        picture->data[0] = ptr;
        picture->data[1] = ptr + size2; /* palette is stored here as 256 32 bit words */
        picture->data[2] = NULL;
        picture->linesize[0] = width;
        picture->linesize[1] = 4;
        return size2 + 256 * 4;
    default:
fail:
        picture->data[0] = NULL;
        picture->data[1] = NULL;
        picture->data[2] = NULL;
        picture->data[3] = NULL;
        return -1;
    }
}

void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift)
{
        *h_shift = pix_fmt_info[pix_fmt].x_chroma_shift;
        *v_shift = pix_fmt_info[pix_fmt].y_chroma_shift;
}    

static void img_copy_plane(uint8_t *dst, int dst_wrap, 
                           const uint8_t *src, int src_wrap,
                           int width, int height)
{
    if((!dst) || (!src)) 
        return;
    for(;height > 0; height--) {
        memcpy(dst, src, width);
        dst += dst_wrap;
        src += src_wrap;
    }
}

int avpicture_alloc(AVPicture *picture,
                           int pix_fmt, int width, int height)
{
    unsigned int size;
    void *ptr;

    size = avpicture_get_size(pix_fmt, width, height);
    if(size<0)
        goto fail;
    ptr = av_malloc(size);
    if (!ptr)
        goto fail;
    avpicture_fill(picture, ptr, pix_fmt, width, height);
    return 0;
 fail:
    memset(picture, 0, sizeof(AVPicture));
    return -1;
}

int avpicture_get_size(int pix_fmt, int width, int height)
{
    AVPicture dummy_pict;
    return avpicture_fill(&dummy_pict, NULL, pix_fmt, width, height);
}

void avpicture_free(AVPicture *picture)
{
    av_free(picture->data[0]);
}

/**
 * Copy image 'src' to 'dst'.
 */
void img_copy(AVPicture *dst, const AVPicture *src,
              int pix_fmt, int width, int height)
{
    int bwidth, bits, i;
    PixFmtInfo *pf = &pix_fmt_info[pix_fmt];
    
    pf = &pix_fmt_info[pix_fmt];
    switch(pf->pixel_type) {
    case FF_PIXEL_PACKED:
        switch(pix_fmt) {
        case PIX_FMT_YUV422:
        case PIX_FMT_UYVY422:
        case PIX_FMT_RGB565:
        case PIX_FMT_RGB555:
            bits = 16;
            break;
	case PIX_FMT_UYVY411:
	    bits = 12;
	    break;
        default:
            bits = pf->depth * pf->nb_channels;
            break;
        }
        bwidth = (width * bits + 7) >> 3;
        img_copy_plane(dst->data[0], dst->linesize[0],
                       src->data[0], src->linesize[0],
                       bwidth, height);
        break;
    case FF_PIXEL_PLANAR:
        for(i = 0; i < pf->nb_channels; i++) {
            int w, h;
            w = width;
            h = height;
            if (i == 1 || i == 2) {
                w >>= pf->x_chroma_shift;
                h >>= pf->y_chroma_shift;
            }
            bwidth = (w * pf->depth + 7) >> 3;
            img_copy_plane(dst->data[i], dst->linesize[i],
                           src->data[i], src->linesize[i],
                           bwidth, h);
        }
        break;
    case FF_PIXEL_PALETTE:
        img_copy_plane(dst->data[0], dst->linesize[0],
                       src->data[0], src->linesize[0],
                       width, height);
        /* copy the palette */
        img_copy_plane(dst->data[1], dst->linesize[1],
                       src->data[1], src->linesize[1],
                       4, 256);
        break;
    }
}