libmpcodecs/ve_nuv.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include "config.h"
   6 #include "mp_msg.h"
   7
   8 #include "m_option.h"
   9
  10 #include "codec-cfg.h"
  11 #include "stream.h"
  12 #include "demuxer.h"
  13 #include "stheader.h"
  14
  15 #include "muxer.h"
  16
  17 #include "img_format.h"
  18 #include "mp_image.h"
  19 #include "vf.h"
  20
  21 #include "libmpdemux/nuppelvideo.h"
  22 #include "native/minilzo.h"
  23 #include "native/RTjpegN.h"
  24
  25 #define LZO_AL(size) (((size) + (sizeof(long) - 1)) / sizeof(long))
  26 #define LZO_IN_LEN          (1024*1024L)
  27 #define LZO_OUT_LEN         (LZO_IN_LEN + LZO_IN_LEN / 64 + 16 + 3)
  28
  29 //===========================================================================//
  30
  31 struct vf_priv_s {
  32   int raw; // Do not use RTjpeg
  33   int lzo; // Use lzo
  34   unsigned int l,c,q; // Mjpeg param
  35   muxer_stream_t* mux;
  36   uint8_t* buffer;
  37
  38   int buf_size;
  39   int tbl_wrote;
  40   lzo_byte *zbuffer;
  41   long __LZO_MMODEL *zmem;
  42 };
  43 #define mux_v (vf->priv->mux)
  44
  45 struct vf_priv_s nuv_priv_dflt = {
  46   0, // raw
  47   1, // lzo
  48   1,1, // l,c
  49   255, // q
  50   NULL,
  51   NULL,
  52   0,0,
  53   NULL,NULL
  54 };
  55
  56 m_option_t nuvopts_conf[]={
  57   {"raw", &nuv_priv_dflt.raw, CONF_TYPE_FLAG, 0, 0, 1, NULL},
  58   {"rtjpeg", &nuv_priv_dflt.raw, CONF_TYPE_FLAG, 0, 1, 0, NULL},
  59   {"lzo", &nuv_priv_dflt.lzo, CONF_TYPE_FLAG, 0, 0, 1, NULL},
  60   {"nolzo", &nuv_priv_dflt.lzo, CONF_TYPE_FLAG, 0, 1, 0, NULL},
  61   {"q", &nuv_priv_dflt.q, CONF_TYPE_INT, M_OPT_RANGE,3,255, NULL},
  62   {"l", &nuv_priv_dflt.l, CONF_TYPE_INT, M_OPT_RANGE,0,20, NULL},
  63   {"c", &nuv_priv_dflt.c, CONF_TYPE_INT, M_OPT_RANGE,0,20, NULL},
  64   {NULL, NULL, 0, 0, 0, 0, NULL}
  65 };
  66
  67 //===========================================================================//
  68
  69
  70 static int config(struct vf_instance_s* vf,
  71         int width, int height, int d_width, int d_height,
  72         unsigned int flags, unsigned int outfmt){
  73
  74   // We need a buffer wich can holda header and a whole YV12 picture
  75   // or a RTJpeg table
  76   vf->priv->buf_size = width*height*3/2+FRAMEHEADERSIZE;
  77   if(vf->priv->buf_size < (int)(128*sizeof(long int) + FRAMEHEADERSIZE))
  78     vf->priv->buf_size = 128*sizeof(long int) + FRAMEHEADERSIZE;
  79
  80   mux_v->bih->biWidth=width;
  81   mux_v->bih->biHeight=height;
  82   mux_v->bih->biSizeImage=mux_v->bih->biWidth*mux_v->bih->biHeight*(mux_v->bih->biBitCount/8);
  83   mux_v->aspect = (float)d_width/d_height;
  84   vf->priv->buffer = realloc(vf->priv->buffer,vf->priv->buf_size);
  85   vf->priv->tbl_wrote = 0;
  86
  87   return 1;
  88 }
  89
  90 static int control(struct vf_instance_s* vf, int request, void* data){
  91
  92   return CONTROL_UNKNOWN;
  93 }
  94
  95 static int query_format(struct vf_instance_s* vf, unsigned int fmt){
  96   if(fmt==IMGFMT_I420) return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW;
  97   return 0;
  98 }
  99
 100 static int put_image(struct vf_instance_s* vf, mp_image_t *mpi){
 101   struct rtframeheader* ench = (struct rtframeheader*)vf->priv->buffer;
 102   uint8_t* data = vf->priv->buffer + FRAMEHEADERSIZE;
 103   uint8_t* zdata = vf->priv->zbuffer + FRAMEHEADERSIZE;
 104   int len = 0, zlen = 0,r;
 105
 106   memset(vf->priv->buffer,0,FRAMEHEADERSIZE); // Reset the header
 107   if(vf->priv->lzo)
 108     memset(vf->priv->zbuffer,0,FRAMEHEADERSIZE);
 109
 110   // This has to be don here otherwise tv with sound doesn't work
 111   if(!vf->priv->tbl_wrote) {
 112     RTjpeg_init_compress((long int*)data,mpi->width,mpi->height,vf->priv->q);
 113     RTjpeg_init_mcompress();
 114
 115     ench->frametype = 'D'; // compressor data
 116     ench->comptype  = 'R'; // compressor data for RTjpeg
 117     ench->packetlength = 128*sizeof(long int);
 118
 119     le2me_rtframeheader(ench);
 120     mux_v->buffer=vf->priv->buffer;
 121     muxer_write_chunk(mux_v,FRAMEHEADERSIZE + 128*sizeof(long int), 0x10);
 122     vf->priv->tbl_wrote = 1;
 123     memset(ench,0,FRAMEHEADERSIZE); // Reset the header
 124   }
 125
 126   // Raw picture
 127   if(vf->priv->raw) {
 128     len = mpi->width*mpi->height*3/2;
 129     // Try lzo ???
 130     if(vf->priv->lzo) {
 131       r = lzo1x_1_compress(mpi->planes[0],mpi->width*mpi->height*3/2,
 132                            zdata,&zlen,vf->priv->zmem);
 133       if(r != LZO_E_OK) {
 134         mp_msg(MSGT_VFILTER,MSGL_ERR,"LZO compress error\n");
 135         zlen = 0;
 136       }
 137     }
 138
 139     if(zlen <= 0 || zlen > len) {
 140       memcpy(data,mpi->planes[0],len);
 141       ench->comptype = '0';
 142     } else { // Use lzo only if it's littler
 143       ench = (struct rtframeheader*)vf->priv->zbuffer;
 144       ench->comptype = '3';
 145       len = zlen;
 146     }
 147
 148   } else { // RTjpeg compression
 149     len = RTjpeg_mcompressYUV420(data,mpi->planes[0],vf->priv->l,
 150                                  vf->priv->c);
 151     if(len <= 0) {
 152       mp_msg(MSGT_VFILTER,MSGL_ERR,"RTjpeg_mcompressYUV420 error (%d)\n",len);
 153       return 0;
 154     }
 155
 156     if(vf->priv->lzo) {
 157       r = lzo1x_1_compress(data,len,zdata,&zlen,vf->priv->zmem);
 158       if(r != LZO_E_OK) {
 159         mp_msg(MSGT_VFILTER,MSGL_ERR,"LZO compress error\n");
 160         zlen = 0;
 161       }
 162     }
 163
 164     if(zlen <= 0 || zlen > len)
 165       ench->comptype = '1';
 166     else {
 167       ench = (struct rtframeheader*)vf->priv->zbuffer;
 168       ench->comptype = '2';
 169       len = zlen;
 170     }
 171
 172   }
 173
 174   ench->frametype = 'V'; // video frame
 175   ench->packetlength = len;
 176   le2me_rtframeheader(ench);
 177   mux_v->buffer=(void*)ench;
 178   muxer_write_chunk(mux_v, len + FRAMEHEADERSIZE, 0x10);
 179   return 1;
 180 }
 181
 182 static void uninit(struct vf_instance_s* vf) {
 183
 184   if(vf->priv->buffer)
 185     free(vf->priv->buffer);
 186   if(vf->priv->zbuffer)
 187     free(vf->priv->zbuffer);
 188   if(vf->priv->zmem)
 189     free(vf->priv->zmem);
 190
 191 }
 192
 193 //===========================================================================//
 194
 195 static int vf_open(vf_instance_t *vf, char* args){
 196   vf->config=config;
 197   vf->default_caps=VFCAP_CONSTANT;
 198   vf->control=control;
 199   vf->query_format=query_format;
 200   vf->put_image=put_image;
 201   vf->uninit = uninit;
 202   vf->priv=malloc(sizeof(struct vf_priv_s));
 203   memcpy(vf->priv, &nuv_priv_dflt,sizeof(struct vf_priv_s));
 204   vf->priv->mux=(muxer_stream_t*)args;
 205
 206   mux_v->bih=calloc(1, sizeof(BITMAPINFOHEADER));
 207   mux_v->bih->biSize=sizeof(BITMAPINFOHEADER);
 208   mux_v->bih->biWidth=0;
 209   mux_v->bih->biHeight=0;
 210   mux_v->bih->biPlanes=1;
 211   mux_v->bih->biBitCount=12;
 212   mux_v->bih->biCompression = mmioFOURCC('N','U','V','1');
 213
 214   if(vf->priv->lzo) {
 215     if(lzo_init() != LZO_E_OK) {
 216       mp_msg(MSGT_VFILTER,MSGL_WARN,"LZO init failed: no lzo compression\n");
 217       vf->priv->lzo = 0;
 218     }
 219     vf->priv->zbuffer = (lzo_bytep)malloc(FRAMEHEADERSIZE + LZO_OUT_LEN);
 220     vf->priv->zmem = (long*)malloc(sizeof(long)*LZO_AL(LZO1X_1_MEM_COMPRESS));
 221   }
 222
 223   return 1;
 224 }
 225
 226 vf_info_t ve_info_nuv = {
 227   "nuv encoder",
 228   "nuv",
 229   "Albeu",
 230   "for internal use by mencoder",
 231   vf_open
 232 };
 233
 234 //===========================================================================//