jpeg_to_avi.c

motion Jpeg 在SPI DSP平台优化好的代码

////////////////////////////////////////////////////////////////////////////////////////////////////
//
//                      jpeg_to_avi.c 
//
//      Notice:         COPYRIGHT (C) STREAM PROCESSORS, INC. 2005-2007
//                      THIS PROGRAM IS PROVIDED UNDER THE TERMS OF THE SPI
//                      END-USER LICENSE AGREEMENT (EULA). THE PROGRAM MAY ONLY
//                      BE USED IN A MANNER EXPLICITLY SPECIFIED IN THE EULA,
//                      WHICH INCLUDES LIMITATIONS ON COPYING, MODIFYING,
//                      REDISTRIBUTION AND WARANTIES. UNAUTHORIZED USE OF THIS
//                      PROGRAM IS STRICTLY PROHIBITED. YOU MAY OBTAIN A COPY OF
//                      THE EULA FROM WWW.STREAMPROCESSORS.COM. 
//    
////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////
//          #includes 
////////////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "avi_context.h"
#include "jpeg_to_avi.h"
#include "spi_macros.h"


//    Routines to create avi.

int spi_jpeg_to_avi_open(void **p_handle)
{
    AVI_CONTEXT_T *p_avi;

    p_avi = (AVI_CONTEXT_T *) malloc (sizeof (AVI_CONTEXT_T));
	if (p_avi == NULL)
	{
		printf ("\n Malloc for avi context failed.\n");
		return ERROR;
	}
    *p_handle = p_avi;
    return SUCCESS;
}

int spi_jpeg_to_avi_init(void *p_handle, AVI_SETTINGS_T *avi_settings)
{
    AVI_CONTEXT_T       *p_avi = p_handle;
    AVI_LIST_HDRL_T     *p_list_hdrl;
    unsigned int        us_per_frame;

    if (avi_settings->fps == 0)
    {
        printf ("Error: Invalid fps value\n");
        return ERROR;
    }
    us_per_frame = 1000000/avi_settings->fps;
    strcpy(p_avi->avi_filename, avi_settings->avi_filename);
    if ((p_avi->f_avi_file = fopen(p_avi->avi_filename,"wb")) == NULL)
    {
        printf ("Error: Cannot open avi file - %s\n", p_avi->avi_filename);
        return ERROR;
    }

    p_avi->frames                           = 0;
    p_avi->jpeg_size                        = 0;

    /* Init AVI header structure */
    memcpy(p_avi->avi_riff.riff_list_hdr.id,  "RIFF", 4);
    p_avi->avi_riff.riff_list_hdr.sz 		= 0;                        /* update at end */
    memcpy(p_avi->avi_riff.riff_list_hdr.type, "AVI ", 4);

    memcpy(p_avi->avi_riff.movi_list_hdr.id,  "LIST", 4);
    p_avi->avi_riff.movi_list_hdr.sz 		= 0;                        /* update at end */
    memcpy(p_avi->avi_riff.movi_list_hdr.type, "movi", 4);

    p_list_hdrl                             = &p_avi->avi_riff.avi_list_hdrl;
    memcpy(p_list_hdrl->list_hdr.id,          "LIST", 4);
    p_list_hdrl->list_hdr.sz 				= sizeof(AVI_LIST_HDRL_T) - 8;
    memcpy(p_list_hdrl->list_hdr.type,        "hdrl", 4);
    memcpy(p_list_hdrl->avih_id,              "avih", 4);
    p_list_hdrl->avih_sz					= sizeof(AVI_AVIH_T);
    p_list_hdrl->avih.us_per_frame			= us_per_frame;
    p_list_hdrl->avih.max_bytes_per_sec		= 0;                        /* update at end */
    p_list_hdrl->avih.padding				= 0;
    p_list_hdrl->avih.flags					= AVIF_HASINDEX;
    p_list_hdrl->avih.tot_frames            = 0;                        /* update at end */
    p_list_hdrl->avih.init_frames			= 0;
    p_list_hdrl->avih.streams				= 1;
    p_list_hdrl->avih.buff_sz				= 0;
    p_list_hdrl->avih.width					= avi_settings->width;
    p_list_hdrl->avih.height				= avi_settings->height;
    p_list_hdrl->avih.reserved[0]			= 0;
    p_list_hdrl->avih.reserved[1]			= 0;
    p_list_hdrl->avih.reserved[2]			= 0;
    p_list_hdrl->avih.reserved[3]			= 0;

    memcpy(p_list_hdrl->strl.list_hdr.id,     "LIST", 4);
    p_list_hdrl->strl.list_hdr.sz 			= sizeof(AVI_STRL_T) - 8;
    memcpy(p_list_hdrl->strl.list_hdr.type,   "strl", 4);
    memcpy(p_list_hdrl->strl.strh_id,         "strh", 4);
    p_list_hdrl->strl.strh_sz				= sizeof(AVI_STRH_T);
    memcpy(p_list_hdrl->strl.strh.type,       "vids", 4);
    memcpy(p_list_hdrl->strl.strh.handler,    "MJPG", 4);
    p_list_hdrl->strl.strh.flags			= 0;
    p_list_hdrl->strl.strh.priority			= 0;
    p_list_hdrl->strl.strh.init_frames		= 0;
    p_list_hdrl->strl.strh.scale			= us_per_frame;
    p_list_hdrl->strl.strh.rate				= 1000000;
    p_list_hdrl->strl.strh.start			= 0;
    p_list_hdrl->strl.strh.length			= 0;                        /* update at end */
    p_list_hdrl->strl.strh.buff_sz			= 0;
    p_list_hdrl->strl.strh.quality			= 0;
    p_list_hdrl->strl.strh.sample_sz		= 0;

    memcpy(p_list_hdrl->strl.strf_id,         "strf", 4);
    p_list_hdrl->strl.strf_sz				= sizeof(AVI_STRF_T);
    p_list_hdrl->strl.strf.sz				= sizeof(AVI_STRF_T);
    p_list_hdrl->strl.strf.width			= avi_settings->width;
    p_list_hdrl->strl.strf.height			= avi_settings->height;
    p_list_hdrl->strl.strf.planes_bit_cnt	= (1 + 24*256*256);
    memcpy(p_list_hdrl->strl.strf.compression, "MJPG", 4);
    p_list_hdrl->strl.strf.image_sz			= (avi_settings->width * avi_settings->height * 3);
    p_list_hdrl->strl.strf.xpels_meter		= 0;
    p_list_hdrl->strl.strf.ypels_meter		= 0;
    p_list_hdrl->strl.strf.num_colors		= 0;
    p_list_hdrl->strl.strf.imp_colors		= 0;

    memcpy(p_list_hdrl->strl.odml.list_hdr.id, "LIST", 4);
    p_list_hdrl->strl.odml.list_hdr.sz 		= sizeof(AVI_ODML_T) - 8;
    memcpy(p_list_hdrl->strl.odml.list_hdr.type, "odml", 4);
    memcpy(p_list_hdrl->strl.odml.dmlh.id,    "dmlh", 4);
    p_list_hdrl->strl.odml.dmlh.sz			= 4;
    p_list_hdrl->strl.odml.dmlh.frames		= 0;                        /* update at end */

    if ((fwrite(&p_avi->avi_riff, 1, sizeof(AVI_RIFF_T), p_avi->f_avi_file)) != sizeof(AVI_RIFF_T))
    {
        printf ("Error: Cannot write RIFF header\n");
        return ERROR;
    }

    /* Init structure to be written before every jpeg frame */
    memcpy(p_avi->avi_jpeg_hdr.jpeg_id,       "00db", 4);
    memcpy(p_avi->avi_jpeg_hdr.avi_id,        "AVI1", 4);

    /* Init index structure to be written at the end */
    memcpy(p_avi->avi_idx_hdr.idx_id,         "idx1", 4);
    memcpy(p_avi->avi_idx_data.jpeg_id,       "00db", 4);
    p_avi->avi_idx_data.unknwn              = 18;

    if ((p_avi->p_start = malloc(sizeof(AVI_IDX_INFO_T))) == NULL)
    {
        printf ("Error: Cannot allocate memory for jpeg index\n");
        return ERROR;
    }
    p_avi->p_curr                           = p_avi->p_start;
    p_avi->p_start->next                    = NULL;

    return SUCCESS;
}

int spi_jpeg_to_avi_add(void *p_handle, AVI_INPUT_T *avi_input)
{
    AVI_CONTEXT_T *p_avi = p_handle;
    int jpeg_size, padded_jpeg_size;

    jpeg_size = avi_input->size;
    if (jpeg_size < 10)
    {
        printf ("Error: Not enough jpeg data : %d bytes\n", jpeg_size);
        return ERROR;
    }
    padded_jpeg_size = (jpeg_size + 3) & ~(3);
    p_avi->avi_jpeg_hdr.jpeg_sz             = padded_jpeg_size;
    memcpy(p_avi->avi_jpeg_hdr.jpeg_hdr, avi_input->input_data, 6);
    if ((fwrite(&p_avi->avi_jpeg_hdr, 1, 18, p_avi->f_avi_file)) != 18)
    {
        printf ("Error: Cannot write JPEG header\n");
        return ERROR;
    }
    if ((fwrite((avi_input->input_data + 10), 1, (jpeg_size - 10), p_avi->f_avi_file)) != (jpeg_size-10))
    {
        printf ("Error: Cannot write JPEG data\n");
        return ERROR;
    }
    if (jpeg_size != padded_jpeg_size)
    {
        if ((fwrite((avi_input->input_data), 1, (padded_jpeg_size - jpeg_size), p_avi->f_avi_file)) != (padded_jpeg_size - jpeg_size))
        {
            printf ("Error: Cannot write JPEG padding data\n");
            return ERROR;
        }
    }
    p_avi->frames++;
    p_avi->jpeg_size    += padded_jpeg_size;
    if (p_avi->jpeg_size > (1024*1024*1024))
    {
        printf ("Error: Exceeded avi size limit of 1GB.\n");
        return ERROR;
    }
    /* Create linked list for storing sizes (for index calculation at end) */
    p_avi->p_curr->size = padded_jpeg_size;
    if ((p_avi->p_curr->next = malloc(sizeof(AVI_IDX_INFO_T))) == NULL)
    {
        printf ("Error: Cannot allocate memory for jpeg index\n");
        return ERROR;
    }
    p_avi->p_curr       = p_avi->p_curr->next;
    p_avi->p_curr->next = NULL;

    return SUCCESS;
}

int spi_jpeg_to_avi_close(void *p_handle)
{
    AVI_CONTEXT_T       *p_avi = p_handle;
    AVI_LIST_HDRL_T     *p_list_hdrl;
    unsigned int        i, offset;

    p_avi->avi_riff.movi_list_hdr.sz 		= p_avi->jpeg_size + (8 * p_avi->frames) + 4;
    p_avi->avi_riff.riff_list_hdr.sz 		= 4 + sizeof(AVI_LIST_HDRL_T) + 8 + p_avi->avi_riff.movi_list_hdr.sz + 8 + (16 * p_avi->frames) ;
    p_list_hdrl                             = &p_avi->avi_riff.avi_list_hdrl;
    p_avi->frames = (p_avi->frames) ? p_avi->frames : 1;
    p_list_hdrl->avih.max_bytes_per_sec		= (1000000 * (p_avi->jpeg_size/p_avi->frames)) / (p_list_hdrl->avih.us_per_frame);
    p_list_hdrl->avih.tot_frames            = p_avi->frames;
    p_list_hdrl->strl.strh.length			= p_avi->frames;
    p_list_hdrl->strl.odml.dmlh.frames		= p_avi->frames;

    /* Create linked list for storing sizes (for index calculation at end) */
    p_avi->avi_idx_hdr.idx_sz               = 16 * p_avi->frames;
    if ((fwrite(&p_avi->avi_idx_hdr, 1, sizeof(AVI_IDX_HDR_T), p_avi->f_avi_file)) != sizeof(AVI_IDX_HDR_T))
    {
        printf ("Error: Cannot write AVI Index header\n");
        return ERROR;
    }

    p_avi->p_curr = p_avi->p_start;
    offset = 4;
    for (i=0; i<(p_avi->frames); i++)
    {
        p_avi->avi_idx_data.offset = offset;
        p_avi->avi_idx_data.jpeg_sz = p_avi->p_curr->size;
        if ((fwrite(&p_avi->avi_idx_data, 1, sizeof(AVI_IDX_DATA_T), p_avi->f_avi_file)) != sizeof(AVI_IDX_DATA_T))
        {
            printf ("Error: Cannot write AVI Index data\n");
            return ERROR;
        }
        offset          += 8 + p_avi->p_curr->size;
        p_avi->p_start  = p_avi->p_curr;
        p_avi->p_curr   = p_avi->p_curr->next;
        free (p_avi->p_start);
    }
    free (p_avi->p_curr);


    /* Update the RIFF structure with sizes and number of frames */
    rewind(p_avi->f_avi_file);
    if ((fwrite(&p_avi->avi_riff, 1, sizeof(AVI_RIFF_T), p_avi->f_avi_file)) != sizeof(AVI_RIFF_T))
    {
        printf ("Error: Cannot write updated RIFF header\n");
        return ERROR;
    }

    fclose(p_avi->f_avi_file);
    free(p_avi);
    return SUCCESS;
}

int spi_jpeg_to_avi_get_avi_size(void *p_handle, unsigned int *size)
{
    AVI_CONTEXT_T       *p_avi = p_handle;

    *size = 12 + sizeof(AVI_LIST_HDRL_T) +  12 + (8 * p_avi->frames) +p_avi->jpeg_size + 8 + (16 * p_avi->frames) ;
    return SUCCESS;
}