fmpeg4.c

基于Linux的ffmepg decoder

/* fmpeg4.c */

#include "fmpeg4.h"

/********************************
   Simple Memory Pool Management 
 ********************************/
 
typedef struct fmpeg4_mempool{
    unsigned int start;    //pa
    unsigned int total_size;
    unsigned int point;    //pa
    unsigned int remain_size;
}fmpeg4_mempool_t;

fmpeg4_mempool_t    fmpeg4pool;
unsigned int        bs_buffer_virt=0;
unsigned int        bs_buffer_phy=0;


#if 0
unsigned int fmpeg4_mempool_init(void)
{
    fmpeg4pool.start=CPE_MEMPOOL_BASE;
    fmpeg4pool.total_size=CPE_MEMPOOL_SIZE;
    fmpeg4pool.point=CPE_MEMPOOL_BASE;
    fmpeg4pool.remain_size=fmpeg4pool.total_size;
    return 1;
}

unsigned int fmpeg4_mempool_alloc(unsigned int size,unsigned int *phy)
{
    if(size>fmpeg4pool.remain_size)
        return 0;
    fmpeg4pool.point+=size;
    fmpeg4pool.remain_size-=size;
    F_DEBUG("fmpeg4_mempool_alloc:addr=0x%x size=0x%x\n",(unsigned int)fmpeg4pool.point,(unsigned int)size);
    *phy=fmpeg4pool.point;
    return (unsigned int)__va(fmpeg4pool.point);
}

unsigned int fmpeg4_mempool_free(unsigned int addr, unsigned int size)
{
    F_DEBUG("fmpeg4_mempool_free: addr=0x%x size=0x%x\n",fmpeg4pool.point,size);
    if((unsigned int)__va(fmpeg4pool.point-size)!=addr)
    {
        F_DEBUG("Fail to free the undefined address!\n");
    }
    fmpeg4pool.point-=size;
    fmpeg4pool.remain_size+=size;
    return 1;
}
#endif

spinlock_t   fmpeg4_lock;

struct file_operations fmpeg4_decoder_fops = {
  	owner:      THIS_MODULE,
	ioctl:		fmpeg4_decoder_ioctl,
	open:		fmpeg4_decoder_open,
	release:	fmpeg4_decoder_release,
};

struct miscdevice fmpeg4_decoder_dev = {
	minor: FMPEG4_DECODER_MINOR,
	name: "fmpeg4 decoder",
	fops: &fmpeg4_decoder_fops,
};

struct file_operations fmpeg4_encoder_fops = {
  	owner:      THIS_MODULE,
	ioctl:		fmpeg4_encoder_ioctl,
	open:		fmpeg4_encoder_open,
	release:	fmpeg4_encoder_release,
};

struct miscdevice fmpeg4_encoder_dev = {
	minor: FMPEG4_ENCODER_MINOR,
	name: "fmpeg4 encoder",
	fops: &fmpeg4_encoder_fops,
};


static int __init init_fmpeg4(void)
{
    int ret;

    F_DEBUG("init_fmpeg4\n");
	if((ret=misc_register(&fmpeg4_decoder_dev))<0)
	{
		F_DEBUG("can't get decoder major number\n");
		return ret;
	}
	if((ret=misc_register(&fmpeg4_encoder_dev))<0)
	{
		F_DEBUG("can't get decoder major number\n");
		return ret;
	}
	spin_lock_init(&fmpeg4_lock);
	fmpeg4_mempool_init();
	bs_buffer_virt=(unsigned int)consistent_alloc(GFP_KERNEL|GFP_DMA,BIT_STREAM_SIZE,&bs_buffer_phy);
	F_DEBUG("alloc bs va=0x%x pa=0x%x\n",bs_buffer_virt,bs_buffer_phy);
    return 0;
}

static void __exit cleanup_fmpeg4(void)
{
    F_DEBUG("cleanup_fmpeg4\n");
    misc_deregister(&fmpeg4_decoder_dev);
    misc_deregister(&fmpeg4_encoder_dev);
    consistent_free((void *)bs_buffer_virt,BIT_STREAM_SIZE,(unsigned int)bs_buffer_virt);
}

module_init(init_fmpeg4);
module_exit(cleanup_fmpeg4);