path: root/converter/ppm/ppmtompeg/frame.c

/*===========================================================================*
 * frame.c                                   *
 *                                       *
 *  basic frame procedures                           *
 *                                       *
 * EXPORTED PROCEDURES:                              *
 *  Frame_Init                               *
 *  Frame_Exit                               *
 *  Frame_New                                *
 *  Frame_Free                               *
 *  Frame_AllocBlocks                            *
 *  Frame_AllocYCC                               *
 *  Frame_AllocDecoded                           *
 *  Frame_AllocHalf                                  *
 *  Frame_Resize                                     * 
 *                                       *
 *===========================================================================*/

/*
 * Copyright (c) 1995 The Regents of the University of California.
 * All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 */


#include "mallocvar.h"

#include "all.h"
#include "mtypes.h"
#include "frames.h"
#include "frame.h"
#include "fsize.h"
#include "dct.h"

/*===========*
 * CONSTANTS *
 *===========*/

/* The maximum number of B-Frames allowed between reference frames. */
#define  B_FRAME_RUN  16    

/*==================*
 * GLOBAL VARIABLES *
 *==================*/

static MpegFrame * frameMemory[B_FRAME_RUN+2];
static unsigned int numOfFrames;


/*====================================================
* Resize_Array_Width
*    
*   This function will resize any array width up
* or down in size.  The algorithm is based on the
* least common multiple approach more commonly
* used in audio frequency adjustments.
*=====================================================*/
static void 
Resize_Array_Width(uint8 ** const inarray,
                   int      const in_x,
                   int      const in_y,
                   uint8 ** const outarray,
                   int      const out_x) {

    unsigned int i;
    int in_total;
    int out_total;
    uint8 *inptr;
    uint8 *outptr;
    uint8 pointA,pointB;
    /* double slope,diff; */
    
    for (i = 0; i < in_y; ++i) {     /* For each row */
        unsigned int j;
        inptr = &inarray[i][0];
        outptr = &outarray[i][0];
        in_total = 0;
        out_total = 0;
        for (j=0; j < out_x; ++j) {      /* For each output value */
            if (in_total == out_total) {
                *outptr = *inptr;
                outptr++;
                out_total=out_total+in_x;
                while(in_total < out_total){
                    in_total = in_total + out_x;
                    ++inptr;
                }
                if (in_total > out_total) {
                    in_total = in_total - out_x;
                    --inptr;
                }
            } else {  
                pointA = *inptr;
                ++inptr;
                pointB = *inptr;
                --inptr;
#if 0
                /*Interpolative solution */
                slope = ((double)(pointB -pointA))/((double)(out_x));
                diff = (((double)(out_total - in_total)));
                if (diff < (out_x/2)){
                    *outptr = (pointA + (uint8)(slope*diff));
                } else {
                    *outptr = (pointB -
                               (uint8)(slope*(((float)(out_x)) - diff)));
                } 
#endif
                /* Non-Interpolative solution */
                *outptr = *inptr;  

                ++outptr;
                out_total = out_total + in_x;
                while(in_total < out_total) {
                    in_total = in_total + out_x;
                    ++inptr;
                }
                if (in_total > out_total) {
                    in_total = in_total - out_x;
                    --inptr;
                }
            }  /* end if */
        }  /* end for each output value */
    }  /* end for each row */
}  /* end main */



/*==============================
* Resize_Array_Height
*
*    Resize any array height larger or smaller.
* Same as Resize_array_Width except pointer
* manipulation must change.
*===============================*/
static void 
Resize_Array_Height(uint8 ** const inarray,
                    int      const in_x,
                    int      const in_y,
                    uint8 ** const outarray,
                    int      const out_y) {

    unsigned int i;

    for(i=0; i < in_x; ++i){    /* for each column */
        int in_total;
        int out_total;
        uint8 pointA, pointB;
        double slope, diff;
        unsigned int j;
        int k;

        in_total = 0;
        out_total = 0;
        k = 0;
        for(j=0; j < out_y; ++j){  /* for each output value */
            if (in_total == out_total) {  
                outarray[j][i] = inarray[k][i];
                out_total=out_total+in_y;
                while(in_total < out_total){
                    in_total = in_total + out_y;
                    ++k;
                }
                if (in_total > out_total) {
                    in_total = in_total - out_y;
                    --k;
                }
            } else {  
                pointA = inarray[k][i];
                if (k != (in_y -1)) {
                    pointB = inarray[k+1][i];
                } else
                    pointB = pointA;
                /* Interpolative case */
                slope = ((double)(pointB -pointA))/(double)(out_y);
                diff = (double)(out_total - in_total);
                /*  outarray[j][i] = (inarray[k][i] + (uint8)(slope*diff)); */
                /* Non-Interpolative case */
                outarray[j][i] = inarray[k][i];
                out_total = out_total + in_y;
                while (in_total < out_total) {
                    in_total = in_total + out_y;
                    ++k;
                }
                if (in_total > out_total){
                    in_total = in_total - out_y;
                    --k;
                }
            } 
        }
    }
}



/*========================================================
* Resize_Width
*======================================================*/
static void  
Resize_Width(MpegFrame * const omfrw,
             MpegFrame * const mfrw,
             int         const in_x,
             int         const in_y,
             int         const out_x) {

    int y;

    omfrw->orig_y = NULL;
    Fsize_x = out_x;

    /* Allocate new frame memory */
    MALLOCARRAY(omfrw->orig_y, Fsize_y);
    ERRCHK(omfrw->orig_y, "malloc");
    for (y = 0; y < Fsize_y; ++y) {
        MALLOCARRAY(omfrw->orig_y[y], out_x);
        ERRCHK(omfrw->orig_y[y], "malloc");
    }

    MALLOCARRAY(omfrw->orig_cr, Fsize_y / 2);
    ERRCHK(omfrw->orig_cr, "malloc");
    for (y = 0; y < Fsize_y / 2; ++y) {
        MALLOCARRAY(omfrw->orig_cr[y], out_x / 2);
        ERRCHK(omfrw->orig_cr[y], "malloc");
    }

    MALLOCARRAY(omfrw->orig_cb, Fsize_y / 2);
    ERRCHK(omfrw->orig_cb, "malloc");
    for (y = 0; y < Fsize_y / 2; ++y) {
        MALLOCARRAY(omfrw->orig_cb[y], out_x / 2);
        ERRCHK(omfrw->orig_cb[y], "malloc");
    }

    if (referenceFrame == ORIGINAL_FRAME) {
        omfrw->ref_y = omfrw->orig_y;
        omfrw->ref_cr = omfrw->orig_cr;
        omfrw->ref_cb = omfrw->orig_cb;
    }

    /* resize each component array separately */
    Resize_Array_Width(mfrw->orig_y, in_x, in_y, omfrw->orig_y, out_x);
    Resize_Array_Width(mfrw->orig_cr, (in_x/2), (in_y/2), omfrw->orig_cr,
                       (out_x/2));
    Resize_Array_Width(mfrw->orig_cb, (in_x/2), (in_y/2), omfrw->orig_cb,
                       (out_x/2));

    /* Free old frame memory */
    if (mfrw->orig_y) {
        unsigned int i;
        for (i = 0; i < in_y; ++i) {
            free(mfrw->orig_y[i]);
        }
        free(mfrw->orig_y);
        
        for (i = 0; i < in_y / 2; ++i) {
            free(mfrw->orig_cr[i]);
        }
        free(mfrw->orig_cr);
        
        for (i = 0; i < in_y / 2; ++i) {
            free(mfrw->orig_cb[i]);
        }
        free(mfrw->orig_cb);
    }
}



/*=======================================================
* Resize_Height
*
*   Resize Frame height up or down
*=======================================================*/
static  void
Resize_Height(MpegFrame * const omfrh,
              MpegFrame * const mfrh,
              int         const in_x,
              int         const in_y,
              int         const out_y) {
    
    unsigned int y; 
    
    Fsize_y = out_y;

    /* Allocate new frame memory */
    MALLOCARRAY(omfrh->orig_y, out_y);
    ERRCHK(omfrh->orig_y, "malloc");
    for (y = 0; y < out_y; ++y) {
        MALLOCARRAY(omfrh->orig_y[y], Fsize_x);
        ERRCHK(omfrh->orig_y[y], "malloc");
    }

    MALLOCARRAY(omfrh->orig_cr, out_y / 2);
    ERRCHK(omfrh->orig_cr, "malloc");
    for (y = 0; y < out_y / 2; ++y) {
        MALLOCARRAY(omfrh->orig_cr[y], Fsize_x / 2);
        ERRCHK(omfrh->orig_cr[y], "malloc");
    }

    MALLOCARRAY(omfrh->orig_cb, out_y / 2);
    ERRCHK(omfrh->orig_cb, "malloc");
    for (y = 0; y < out_y / 2; ++y) {
        MALLOCARRAY(omfrh->orig_cb[y], Fsize_x / 2);
        ERRCHK(omfrh->orig_cb[y], "malloc");
    }

    if (referenceFrame == ORIGINAL_FRAME) {
        omfrh->ref_y = omfrh->orig_y;
        omfrh->ref_cr = omfrh->orig_cr;
        omfrh->ref_cb = omfrh->orig_cb;
    }

    /* resize component arrays separately */
    Resize_Array_Height(mfrh->orig_y, in_x, in_y, omfrh->orig_y, out_y);
    Resize_Array_Height(mfrh->orig_cr, (in_x/2), (in_y/2), omfrh->orig_cr,
                        (out_y/2));
    Resize_Array_Height(mfrh->orig_cb, (in_x/2), (in_y/2), omfrh->orig_cb,
                        (out_y/2));

    /* Free old frame memory */
    if (mfrh->orig_y) {
        unsigned int i;
        for (i = 0; i < in_y; ++i) {
            free(mfrh->orig_y[i]);
        }
        free(mfrh->orig_y);
        
    for (i = 0; i < in_y / 2; ++i) {
        free(mfrh->orig_cr[i]);
    }
    free(mfrh->orig_cr);
    
    for (i = 0; i < in_y / 2; ++i) {
        free(mfrh->orig_cb[i]);
    }
    free(mfrh->orig_cb);
    }
}



/*===========================================================================*
 *
 * Frame_Init
 *
 *  initializes the memory associated with all frames ever
 *  If the input is not coming in from stdin, only 3 frames are needed ;
 *      else, the program must create frames equal to the greatest distance
 *      between two reference frames to hold the B frames while it is parsing
 *      the input from stdin.
 *
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    frameMemory, numOfFrames
 *
 *===========================================================================*/
void
Frame_Init(unsigned int const numOfFramesRequested) {
    int idx;

    numOfFrames = numOfFramesRequested;

    for (idx = 0; idx < numOfFrames; ++idx) {
        MALLOCVAR(frameMemory[idx]);
        frameMemory[idx]->inUse = FALSE;
        frameMemory[idx]->orig_y = NULL;    
        frameMemory[idx]->y_blocks = NULL; 
        frameMemory[idx]->decoded_y = NULL;
        frameMemory[idx]->halfX = NULL;
        frameMemory[idx]->next = NULL;
    }
}


/*===========================================================================*
 *
 * FreeFrame
 *
 *  frees the memory associated with the given frame
 *
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
static void
FreeFrame(MpegFrame * const frameP) {

    if (frameP) {
        if (frameP->orig_y) {
            unsigned int i;
            for (i = 0; i < Fsize_y; ++i)
                free(frameP->orig_y[i]);
            free(frameP->orig_y);

            for (i = 0; i < (Fsize_y / 2); ++i)
                free(frameP->orig_cr[i]);
            free(frameP->orig_cr);

            for (i = 0; i < (Fsize_y / 2); ++i)
                free(frameP->orig_cb[i]);
            free(frameP->orig_cb);
        }
        if (frameP->decoded_y) {
            unsigned int i;
            for (i = 0; i < Fsize_y; ++i)
                free(frameP->decoded_y[i]);
            free(frameP->decoded_y);

            for (i = 0; i < (Fsize_y / 2); ++i)
                free(frameP->decoded_cr[i]);
            free(frameP->decoded_cr);

            for (i = 0; i < (Fsize_y / 2); ++i)
                free(frameP->decoded_cb[i]);
            free(frameP->decoded_cb);
        }

        if (frameP->y_blocks) {
            unsigned int i;
            for (i = 0; i < Fsize_y / DCTSIZE; ++i)
                free(frameP->y_blocks[i]);
            free(frameP->y_blocks);

            for (i = 0; i < Fsize_y / (2 * DCTSIZE); ++i)
                free(frameP->cr_blocks[i]);
            free(frameP->cr_blocks);

            for (i = 0; i < Fsize_y / (2 * DCTSIZE); ++i)
                free(frameP->cb_blocks[i]);
            free(frameP->cb_blocks);
        }
        if (frameP->halfX) {
            unsigned int i;
            for ( i = 0; i < Fsize_y; ++i )
                free(frameP->halfX[i]);
            free(frameP->halfX);
            
            for (i = 0; i < Fsize_y-1; ++i)
                free(frameP->halfY[i]);
            free(frameP->halfY);
            
            for (i = 0; i < Fsize_y-1; ++i)
                free(frameP->halfBoth[i]);
            free(frameP->halfBoth);
        }
        free(frameP);
    }
}



/*===========================================================================*
 *
 * Frame_Exit
 *
 *  frees the memory associated with frames
 *
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    frameMemory
 *
 *===========================================================================*/
void
Frame_Exit(void) {

    int idx;

    for (idx = 0; idx < numOfFrames; ++idx) {
        FreeFrame(frameMemory[idx]);
    }
}


/*===========================================================================*
 *
 * Frame_Free
 *
 *  frees the given frame -- allows it to be re-used
 *
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
void
Frame_Free(MpegFrame * const frameP) {
    frameP->inUse = FALSE;
}



/*===========================================================================*
 *
 * GetUnusedFrame
 *
 *  return an unused frame
 *
 * RETURNS: the frame
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
static MpegFrame *
GetUnusedFrame() {
    unsigned int idx;

    for (idx = 0; idx < numOfFrames; ++idx) {
        if (!frameMemory[idx]->inUse) {
            frameMemory[idx]->inUse = TRUE;
            break;
        }
    }
    if (idx >= numOfFrames) {
        fprintf(stderr, "ERROR:  No unused frames!!!\n");
        fprintf(stderr, "        If you are using stdin for input, "
                "it is likely that you have too many\n");
        fprintf(stderr, "        B-frames between two reference frames.  "
                "See the man page for help.\n");
        exit(1);
    }
    return frameMemory[idx]; 
}



/*===========================================================================*
 *
 * ResetFrame
 *
 *  reset a frame to the given id and type
 *
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
static void
ResetFrame(int         const id,
           int         const type,
           MpegFrame * const frame) {

    switch (type) {
    case 'i':
        frame->type = TYPE_IFRAME;
        break;
    case 'p':
        frame->type = TYPE_PFRAME;
        break;
    case 'b':
        frame->type = TYPE_BFRAME;
        break;
    default:
        fprintf(stderr, "Invalid MPEG frame type %c\n", type);
        exit(1);
    }

    frame->id = id;
    frame->halfComputed = FALSE;
    frame->next = NULL;
}



/*===========================================================================*
 *
 * Frame_New
 *
 *  finds a frame that isn't currently being used and resets it
 *
 * RETURNS: the frame
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
MpegFrame *
Frame_New(int const id,
          int const type) {

    MpegFrame *frame;

    frame = GetUnusedFrame();
    ResetFrame(id, type, frame);

    return frame;
}



/*===========================================================================*
 *
 * Frame_AllocBlocks
 *
 *  allocate memory for blocks for the given frame, if required
 *
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
void
Frame_AllocBlocks(MpegFrame * const frameP) {

    if (frameP->y_blocks != NULL) {
        /* already allocated */
    } else {
        int const dctx = Fsize_x / DCTSIZE;
        int const dcty = Fsize_y / DCTSIZE;

        unsigned int i;

        MALLOCARRAY(frameP->y_blocks, dcty);
        ERRCHK(frameP->y_blocks, "malloc");
        for (i = 0; i < dcty; ++i) {
            MALLOCARRAY(frameP->y_blocks[i], dctx);
            ERRCHK(frameP->y_blocks[i], "malloc");
        }
    
        MALLOCARRAY(frameP->cr_blocks, dcty / 2);
        ERRCHK(frameP->cr_blocks, "malloc");
        MALLOCARRAY(frameP->cb_blocks, dcty / 2);
        ERRCHK(frameP->cb_blocks, "malloc");
        for (i = 0; i < (dcty / 2); ++i) {
            MALLOCARRAY(frameP->cr_blocks[i], dctx / 2);
            ERRCHK(frameP->cr_blocks[i], "malloc");
            MALLOCARRAY(frameP->cb_blocks[i], dctx / 2);
            ERRCHK(frameP->cb_blocks[i], "malloc");
        }
    }
}



/*===========================================================================*
 *
 * Frame_AllocYCC
 *
 *  allocate memory for YCC info for the given frame, if required
 *
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
void
Frame_AllocYCC(MpegFrame * const frameP) {

    if (frameP->orig_y != NULL) {
        /* already allocated */
    } else {
        unsigned int y;
    
        DBG_PRINT(("ycc_calc:\n"));
        /*
         * first, allocate tons of memory
         */
        MALLOCARRAY(frameP->orig_y, Fsize_y);
        ERRCHK(frameP->orig_y, "malloc");
        for (y = 0; y < Fsize_y; ++y) {
            MALLOCARRAY(frameP->orig_y[y], Fsize_x);
            ERRCHK(frameP->orig_y[y], "malloc");
        }

        MALLOCARRAY(frameP->orig_cr, Fsize_y / 2);
        ERRCHK(frameP->orig_cr, "malloc");
        for (y = 0; y < (Fsize_y / 2); ++y) {
            MALLOCARRAY(frameP->orig_cr[y], Fsize_x / 2);
            ERRCHK(frameP->orig_cr[y], "malloc");
        }

        MALLOCARRAY(frameP->orig_cb, Fsize_y / 2);
        ERRCHK(frameP->orig_cb, "malloc");
        for (y = 0; y < (Fsize_y / 2); ++y) {
            MALLOCARRAY(frameP->orig_cb[y], Fsize_x / 2);
            ERRCHK(frameP->orig_cb[y], "malloc");
        }

        if (referenceFrame == ORIGINAL_FRAME) {
            frameP->ref_y  = frameP->orig_y;
            frameP->ref_cr = frameP->orig_cr;
            frameP->ref_cb = frameP->orig_cb;
        }
    }
}



/*===========================================================================*
 *
 * Frame_AllocHalf
 *
 *  allocate memory for half-pixel values for the given frame, if required
 *
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
void
Frame_AllocHalf(MpegFrame * const frameP) {

    if (frameP->halfX != NULL) {
    } else {
        unsigned int y;

        MALLOCARRAY(frameP->halfX, Fsize_y);
        ERRCHK(frameP->halfX, "malloc");
        for (y = 0; y < Fsize_y; ++y) {
            MALLOCARRAY(frameP->halfX[y], Fsize_x - 1);
            ERRCHK(frameP->halfX[y], "malloc");
        }
        MALLOCARRAY(frameP->halfY, Fsize_y - 1);
        ERRCHK(frameP->halfY, "malloc");
        for (y = 0; y < Fsize_y - 1; ++y) {
            MALLOCARRAY(frameP->halfY[y], Fsize_x);
            ERRCHK(frameP->halfY[y], "malloc");
        }
        MALLOCARRAY(frameP->halfBoth, Fsize_y - 1);
        ERRCHK(frameP->halfBoth, "malloc");
        for (y = 0; y < Fsize_y - 1; ++y) {
            MALLOCARRAY(frameP->halfBoth[y], Fsize_x - 1);
            ERRCHK(frameP->halfBoth[y], "malloc");
        }
    }
}



/*===========================================================================*
 *
 * Frame_AllocDecoded
 *
 *  allocate memory for decoded frame for the given frame, if required
 *  if makeReference == TRUE, then makes it reference frame
 * 
 * RETURNS: nothing
 *
 * SIDE EFFECTS:    none
 *
 *===========================================================================*/
void
Frame_AllocDecoded(MpegFrame * const frameP,
                   boolean     const makeReference) {

    if (frameP->decoded_y != NULL) {
        /* already allocated */
    } else {
        unsigned int y;

        /* allocate memory for decoded image */
        /* can probably reuse original image memory, but may decide to use
           it for some reason, so do it this way at least for now -- more
           flexible
        */
        MALLOCARRAY(frameP->decoded_y, Fsize_y);
        ERRCHK(frameP->decoded_y, "malloc");
        for (y = 0; y < Fsize_y; ++y) {
            MALLOCARRAY(frameP->decoded_y[y], Fsize_x);
            ERRCHK(frameP->decoded_y[y], "malloc");
        }
        
        MALLOCARRAY(frameP->decoded_cr, Fsize_y / 2);
        ERRCHK(frameP->decoded_cr, "malloc");
        for (y = 0; y < (Fsize_y / 2); ++y) {
            MALLOCARRAY(frameP->decoded_cr[y], Fsize_x / 2);
            ERRCHK(frameP->decoded_cr[y], "malloc");
        }
        
        MALLOCARRAY(frameP->decoded_cb, Fsize_y / 2);
        ERRCHK(frameP->decoded_cb, "malloc");
        for (y = 0; y < (Fsize_y / 2); ++y) {
            MALLOCARRAY(frameP->decoded_cb[y], Fsize_x / 2);
            ERRCHK(frameP->decoded_cb[y], "malloc");
        }

        if (makeReference) {
            frameP->ref_y  = frameP->decoded_y;
            frameP->ref_cr = frameP->decoded_cr;
            frameP->ref_cb = frameP->decoded_cb;
        }
    }
}



/*===============================================================
 *
 * Frame_Resize                  by James Boucher
 *                Boston University Multimedia Communications Lab
 *  
 *     This function takes the mf input frame, read in READFrame(),
 * and resizes all the input component arrays to the output
 * dimensions specified in the parameter file as OUT_SIZE.
 * The new frame is returned with the omf pointer.  As well,
 * the values of Fsize_x and Fsize_y are adjusted.
 ***************************************************************/
void
Frame_Resize(MpegFrame * const omf,
             MpegFrame * const mf,
             int         const insize_x,
             int         const insize_y,
             int         const outsize_x,
             int         const outsize_y) {

    MpegFrame * frameAP;  /* intermediate frame */

    MALLOCVAR_NOFAIL(frameAP);
    
    if (insize_x != outsize_x && insize_y != outsize_y) {
        Resize_Width(frameAP, mf, insize_x, insize_y, outsize_x);
        Resize_Height(omf, frameAP, outsize_x, insize_y, outsize_y);
    } else 
        if (insize_x ==outsize_x && insize_y != outsize_y) {
            Resize_Height(omf, mf, insize_x, insize_y, outsize_y);
        } else
            if (insize_x !=outsize_x && insize_y == outsize_y) {
                Resize_Width(omf, mf, insize_x, insize_y, outsize_x);
            } else
                exit(1);

    free(frameAP);
    free(mf);
}