Subversion Repositories funbase_ip_library

/*---------------------------------------------------------------------------
 *
 *  Course:   SoC design 
 *
 *  File:     main.c 
 *
 *  Purpose:  This is main code of H.263 video encoder 
 *
 *  Group:  
 *          
 *  Authors:
 *
 * 
 *  Notes:    This encoder code implements only a part of H.263 features.
 *            As you know, H.263 standard defines only the decoder - not 
 *            the encoder. Thus, this encoder code produces bitstream that
 *            any H.263 compliant decoder is able to decode. 
 *
 *            This implementation is an extremely simplified version 
 *            H.263 video encoder. For instance, parallel execution and 
 *            motion estimation is not applied at all in these codes.
 *            Limitations:
 *            - Only INTRA coding mode is supported
 *            - Only QCIF picture format supported
 *            - None of the optional coding modes supported
 *
 *---------------------------------------------------------------------------
 */
 
//#include <assert.h>
#include <mcapi.h>
#include <stdio.h>
 
#include "headers.h"
//#include "carphone_data.h"
 
 
FILE* OUTPUT_STREAM;
 
#define XMBS 11
#define YMBS 9
 
// MACRO BLOCK COUNT FOR DCT
#define MB_COUNT 6
#define MB_SIZE 64 
 
// MCAPI NODE NUMBER
#define MAIN_NODE_NUM 0
#define DCT_NODE_NUM 1
 
#define WAIT_TIMEOUT 0xFFFFFFFF
 
#define mcapi_assert_success(s) \
        if (s != MCAPI_SUCCESS) { printf("%s:%d status %d\n", __FILE__, __LINE__, s); abort(); }
 
 
 
int encoder(){
 
  //printf("Encoder starts MCAPI initialization\r\n");
 
  // mcapi initialization starts here
  mcapi_priority_t priority = 1;
  mcapi_status_t status;
  mcapi_request_t request, send_request, recv_request;
  size_t size, recv_size, send_size;
  mcapi_version_t version;
  mcapi_endpoint_t  block_count_out, dct_data_out, dct_data_in , 
    ext_dct_data_in, ext_dct_data_out, ext_dct_block_count_in;  
 
  mcapi_pktchan_send_hndl_t       send_handle;
  mcapi_pktchan_recv_hndl_t       recv_handle;
 
  unsigned int my_node_id = MAIN_NODE_NUM;
 
  mcapi_initialize(my_node_id,&version,&status);
  mcapi_assert_success(status);
 
  /* create endpoints */
  block_count_out = mcapi_create_endpoint ( 0 ,&status);
  mcapi_assert_success(status);
 
  dct_data_out = mcapi_create_endpoint ( 1 ,&status);
  mcapi_assert_success(status);
 
  dct_data_in = mcapi_create_endpoint ( 2 ,&status);
  mcapi_assert_success(status);
 
  //printf("Endpoints created succesfully\r\n");
 
  /* get DCT's endpoints from database */ 
  ext_dct_data_in = mcapi_get_endpoint (DCT_NODE_NUM, 1,&status);
  mcapi_assert_success(status);
 
  ext_dct_data_out = mcapi_get_endpoint (DCT_NODE_NUM, 2, &status);
  mcapi_assert_success(status);
 
  ext_dct_block_count_in = mcapi_get_endpoint (DCT_NODE_NUM, 0, &status);
  mcapi_assert_success(status);
 
  //printf("Remote endpoints obtained succesfully\r\n");
 
  /* connect packet channels */
  mcapi_connect_pktchan_i(dct_data_out , ext_dct_data_in,&request,&status);
  while (!mcapi_test(&request,&size,&status)) {}
  mcapi_assert_success(status);
 
  mcapi_connect_pktchan_i(ext_dct_data_out, dct_data_in,&request,&status);
  while (!mcapi_test(&request,&size,&status)) {}
  mcapi_assert_success(status);
 
  //printf("Packet channels connected succesfully\r\n");
 
  /* open pktchan for sending macroblocks */
  mcapi_open_pktchan_send_i(&send_handle, dct_data_out, &send_request, &status);
  //printf("First channel opened!\r\n");
  mcapi_assert_success(status);
 
  /* open pktchan for receiving macroblocks from DCT */
  mcapi_open_pktchan_recv_i(&recv_handle, dct_data_in, &recv_request, &status);
  mcapi_assert_success(status);
  //printf("Second channel opened!\r\n");
 
  mcapi_wait(&send_request, &size, &status, WAIT_TIMEOUT);	
  mcapi_assert_success(status);
 
  //printf("First wait!\r\n");
 
  mcapi_wait(&recv_request, &size, &status, WAIT_TIMEOUT);	
  mcapi_assert_success(status);
 
  //printf("MCAPI initialization done!\r\n");
 
 
  size = 1;
  uint8 msg = MB_COUNT;
 
  //printf("Sending configuration message to DCT!\r\n");
  mcapi_msg_send(block_count_out, ext_dct_block_count_in, &msg, size, priority,&status);
 
  sint32 lastFrame;
  uint8 currentImage[38016];
 
  vchar inputFileName[] = "carphone.qcif";
  vchar streamFileName[] = "carphone.263";
 
  unsigned int cur_frame;
 
  BitStreamType stream;
 
  FILE *inputfile;
 
  inputfile=yuvOpenInputFile(inputFileName, &lastFrame);
 
 
  //  assert(inputfile != NULL);
 
 
  bitstreamInitBuffer(&stream);
  stream.file=fopen(streamFileName, "wb");
 
  uint8 *mb_data;
  MBType dct_data;
 
  mb_data=(uint8*)malloc(MB_COUNT*MB_SIZE);
  dct_data.data=(sint16*)malloc(2*MB_COUNT*MB_SIZE);
//  char start;
//  getc(start);
 
  for(cur_frame=0;cur_frame<lastFrame;cur_frame++)
  {
    yuvReadFrame(inputfile,currentImage);
    //currentImage=&carphone_data[cur_frame*38016];
 
    PictureType ptype;
    ptype.TR=cur_frame;
    ptype.QUANT=QPI_DEF;
    codePictureHeader(&ptype,&stream);
 
    unsigned int xpos,ypos;
/*
    uint8 *mb_data;
    MBType dct_data;
 
 
    mb_data=(uint8*)malloc(MB_COUNT*MB_SIZE);
    dct_data.data=(sint16*)malloc(2*MB_COUNT*MB_SIZE);
  */  
    send_size = MB_COUNT*MB_SIZE;
 
    //sint16 *incoming;
 
    for(ypos=0;ypos<YMBS; ypos++)
    {
      for(xpos=0;xpos<XMBS; xpos++)
      {
	//printf("Blokin aloitus: f=%d: x=%d, y=%d\r\n", cur_frame, xpos, ypos);
       memoryLoadMB(ypos,xpos,(unsigned char*)currentImage, mb_data);
       //printf("Memory load ok.\r\n");
 
       /* send six macro blocks to dct via mcapi */
       //printf("Sending macroblock packets to DCT.\r\n");
       mcapi_pktchan_send(send_handle, mb_data, send_size, &status);
       mcapi_assert_success(status);
       //printf("Sent successfully!\r\n");
 
       /* receive data from dct */
       mcapi_pktchan_recv(recv_handle,(void *)&dct_data.data ,&recv_size,&status);
       mcapi_assert_success(status);
 
 
       //printf("Received transformed macroblocks from DCT.\r\n");
       fdct_8x8(mb_data, dct_data.data, 6);
       // printf("fdct ok.\r\n");
       quantizeIntraMB(QPI_DEF, &dct_data);
       //printf("quantize ok.\r\n");
       codeIntraMB(&dct_data, &stream);
       //printf("code ok.\r\n");
 
       mcapi_pktchan_free(dct_data.data, &status);
      }
    }
 
 
    bitstreamAlign(&stream);
 
 
  }
    free(mb_data);
    //free(dct_data.data);
 
  bitstreamFlushBufferToFile(&stream);
 
  fclose(stream.file);
  //printf("Job well done!\n");
  return 1;
}