git.maemo.org Git - mardrone/blob - mardrone/ARDrone_SDK_Version_1_8_20110726/ARDroneLib/VLIB/video_controller.c

   1 #include <VP_Os/vp_os_malloc.h>
   2 #include <VP_Os/vp_os_assert.h>
   3
   4 #include <VLIB/video_controller.h>
   5 #include <VLIB/video_codec.h>
   6 #include <VLIB/video_picture.h>
   7 #include <VP_Os/vp_os_print.h>
   8 #include <VLIB/Platform/video_config.h>
   9
  10 #ifdef _ELINUX
  11 #include "dma_malloc.h"
  12 #define vp_os_aligned_realloc(A,B,C) dma_realloc(A,B)
  13 #define vp_os_aligned_free(A) dma_free(A)
  14 #endif
  15
  16 extern C_RESULT video_utils_set_format( uint32_t width, uint32_t height );
  17
  18 C_RESULT video_controller_update( video_controller_t* controller, bool_t complete )
  19 {
  20   video_codec_t* video_codec = controller->video_codec;
  21
  22   controller->current_bits  += controller->in_stream.index << 5; // Index is an index in a int32_t array (32 bits)
  23
  24   if( complete )
  25   {
  26     controller->num_frames   += 1;
  27     controller->output_bits   = controller->current_bits;
  28     controller->current_bits  = 0;
  29   }
  30
  31   video_codec->update( controller );
  32
  33   return C_OK;
  34 }
  35
  36 C_RESULT video_controller_set_mode( video_controller_t* controller, uint32_t mode )
  37 {
  38   controller->mode = mode;
  39
  40   return C_OK;
  41 }
  42
  43 C_RESULT video_controller_set_bitrate( video_controller_t* controller, uint32_t target )
  44 {
  45   controller->target_bitrate = target;
  46
  47   return C_OK;
  48 }
  49
  50 C_RESULT video_controller_set_target_size( video_controller_t* controller, uint32_t target )
  51 {
  52   controller->target_size = target;
  53
  54   return C_OK;
  55 }
  56
  57 static void video_realloc_buffers( video_controller_t* controller, int32_t num_prev_blockline )
  58 {
  59   int32_t i, j;
  60   int16_t* cache;
  61   video_gob_t* gob;
  62   video_macroblock_t* mb;
  63
  64   // Realloc global cache (YUV420 format)
  65   if (controller->codec_type == P264_CODEC)
  66   {
  67     // realloc nb_macroblocks (MB_p264_t type) per picture
  68     controller->cache = (int16_t*) vp_os_aligned_realloc( controller->cache,
  69                                                         (controller->width>>4) * (controller->height>>4) * sizeof(MB_p264_t),
  70                                                         VLIB_ALLOC_ALIGN );
  71     vp_os_memset( controller->cache, 0, (controller->width>>4) * (controller->height>>4) * sizeof(MB_p264_t));
  72   }
  73   else
  74   {
  75     controller->cache = (int16_t*) vp_os_aligned_realloc( controller->cache,
  76                                                           3 * controller->width * controller->height * sizeof(int16_t) / 2,
  77                                                           VLIB_ALLOC_ALIGN );
  78     vp_os_memset( controller->cache, 0, 3 * controller->width * controller->height * sizeof(int16_t) / 2 );
  79   }
  80
  81   // Realloc buffers
  82   cache = controller->cache;
  83   i = controller->num_blockline;
  84   j = controller->mb_blockline;
  85
  86   controller->gobs = (video_gob_t*) vp_os_realloc(controller->gobs, i * sizeof(video_gob_t));
  87   vp_os_memset( controller->gobs, 0, i * sizeof(video_gob_t) );
  88
  89   gob = &controller->gobs[0];
  90   gob->macroblocks = (video_macroblock_t*) vp_os_realloc( gob->macroblocks, i * j * sizeof(video_macroblock_t));
  91   vp_os_memset( gob->macroblocks, 0, i * j * sizeof(video_gob_t) );
  92
  93   video_macroblock_t * macroblock_root = gob->macroblocks;
  94
  95   for(; i > 0; i-- )
  96   {
  97     j = controller->mb_blockline;
  98
  99     gob->macroblocks = macroblock_root;
 100     macroblock_root +=  controller->mb_blockline;
 101
 102     mb = &gob->macroblocks[0];
 103     for(; j > 0; j-- )
 104     {
 105       mb->data = cache;
 106
 107       if (controller->codec_type == P264_CODEC)
 108       {
 109         cache   += sizeof(MB_p264_t)/sizeof(mb->data[0]);
 110       }
 111       else
 112       {
 113         cache   += MCU_BLOCK_SIZE*6;
 114       }
 115       mb ++;
 116     }
 117
 118     gob ++;
 119   }
 120 }
 121
 122 C_RESULT video_controller_cleanup( video_controller_t* controller )
 123 {
 124   video_gob_t* gob;
 125
 126   if( controller->gobs != NULL )
 127   {
 128     gob = &controller->gobs[0];
 129     vp_os_free(gob->macroblocks);
 130     vp_os_free( controller->gobs );
 131   }
 132
 133   if( controller->cache != NULL )
 134   {
 135     vp_os_aligned_free( controller->cache );
 136   }
 137
 138   return C_OK;
 139 }
 140
 141 C_RESULT video_controller_set_format( video_controller_t* controller, int32_t width, int32_t height )
 142 {
 143   int32_t num_prev_blockline;
 144
 145   VP_OS_ASSERT( (width != 0) && (height != 0) );
 146
 147   if( width != controller->width || controller->height != height )
 148   {
 149     controller->resolution_changed = TRUE;
 150     controller->width   = width;
 151     controller->height  = height;
 152
 153     num_prev_blockline = controller->num_blockline;
 154
 155     controller->num_blockline = height >> 4;
 156     controller->mb_blockline  = width >> 4;
 157
 158     video_realloc_buffers( controller, num_prev_blockline );
 159
 160     video_utils_set_format( width, height );
 161   }
 162   else
 163     controller->resolution_changed = FALSE;
 164
 165   return C_OK;
 166 }
 167
 168 C_RESULT  video_controller_set_picture_type( video_controller_t* controller, uint32_t type )
 169 {
 170   controller->picture_type = type;
 171
 172   return C_OK;
 173 }
 174
 175 C_RESULT  video_controller_set_motion_estimation( video_controller_t* controller, bool_t use_me )
 176 {
 177   controller->use_me = use_me;
 178
 179   return C_OK;
 180 }