libmpcodecs/ve_raw.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "config.h"
  24 #include "mp_msg.h"
  25 #include "help_mp.h"
  26
  27 #include "codec-cfg.h"
  28 #include "stream/stream.h"
  29 #include "libmpdemux/demuxer.h"
  30 #include "libmpdemux/stheader.h"
  31
  32 #include "stream/stream.h"
  33 #include "libmpdemux/muxer.h"
  34
  35 #include "img_format.h"
  36 #include "mp_image.h"
  37 #include "vf.h"
  38
  39
  40 //===========================================================================//
  41
  42 struct vf_priv_s {
  43     muxer_stream_t* mux;
  44 };
  45 #define mux_v (vf->priv->mux)
  46
  47 static int set_format(struct vf_instance *vf, unsigned int fmt) {
  48     if (!force_fourcc)
  49         mux_v->bih->biCompression = fmt;
  50
  51     mux_v->bih->biPlanes = 1;
  52     if (IMGFMT_IS_RGB(fmt)) {
  53         if (IMGFMT_RGB_DEPTH(fmt) < 8 && !(fmt&128))
  54             mux_v->bih->biBitCount = IMGFMT_RGB_DEPTH(fmt);
  55         else
  56             mux_v->bih->biBitCount = (IMGFMT_RGB_DEPTH(fmt)+7)&(~7);
  57         return 1;
  58     }
  59     if (IMGFMT_IS_BGR(fmt)) {
  60         if (IMGFMT_BGR_DEPTH(fmt) < 8 && !(fmt&128))
  61             mux_v->bih->biBitCount = IMGFMT_BGR_DEPTH(fmt);
  62         else
  63             mux_v->bih->biBitCount = (IMGFMT_BGR_DEPTH(fmt)+7)&(~7);
  64         return 1;
  65     }
  66     switch (fmt) {
  67     case IMGFMT_I420:
  68     case IMGFMT_IYUV:
  69     case IMGFMT_YV12:
  70     case IMGFMT_411P:
  71         mux_v->bih->biPlanes = 3;
  72         mux_v->bih->biBitCount = 12;
  73         break;
  74     case IMGFMT_444P:
  75         mux_v->bih->biPlanes = 3;
  76         mux_v->bih->biBitCount = 24;
  77         break;
  78     case IMGFMT_422P:
  79         mux_v->bih->biPlanes = 3;
  80         mux_v->bih->biBitCount = 16;
  81         break;
  82     case IMGFMT_IF09:
  83         mux_v->bih->biPlanes = 4;
  84     case IMGFMT_YVU9:
  85         mux_v->bih->biBitCount = 9;
  86         break;
  87     case IMGFMT_UYVY:
  88     case IMGFMT_YUY2:
  89         mux_v->bih->biBitCount = 16;
  90         break;
  91     case IMGFMT_Y8:
  92         mux_v->bih->biBitCount = 8;
  93         break;
  94     default:
  95         mp_tmsg(MSGT_MENCODER, MSGL_INFO, "[VE_RAW] Raw output with FourCC [%x] not supported!\n", fmt);
  96         mux_v->bih->biCompression = 0;
  97         return 0;
  98     }
  99     return 1;
 100 }
 101
 102
 103 static int config(struct vf_instance *vf,
 104         int width, int height, int d_width, int d_height,
 105         unsigned int flags, unsigned int outfmt)
 106 {
 107     int ret;
 108     mux_v->bih->biWidth = width;
 109     mux_v->bih->biHeight = height;
 110     mux_v->aspect = (float)d_width/d_height;
 111     ret = set_format(vf, outfmt);
 112     if (!ret) return 0;
 113
 114     mux_v->bih->biSizeImage = mux_v->bih->biWidth*mux_v->bih->biHeight*mux_v->bih->biBitCount/8;
 115     return 1;
 116 }
 117
 118 static int control(struct vf_instance *vf, int request, void *data) {
 119     return CONTROL_UNKNOWN;
 120 }
 121
 122 static int query_format(struct vf_instance *vf, unsigned int fmt) {
 123     if (IMGFMT_IS_RGB(fmt) || IMGFMT_IS_BGR(fmt))
 124         return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW;
 125     switch (fmt) {
 126     case IMGFMT_I420:
 127     case IMGFMT_IYUV:
 128     case IMGFMT_YV12:
 129     case IMGFMT_411P:
 130     case IMGFMT_444P:
 131     case IMGFMT_422P:
 132     case IMGFMT_UYVY:
 133     case IMGFMT_YUY2:
 134     case IMGFMT_YVU9:
 135     case IMGFMT_IF09:
 136     case IMGFMT_Y8:
 137         return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW;
 138     }
 139
 140     return 0;
 141 }
 142
 143 static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts) {
 144     mux_v->buffer = mpi->planes[0];
 145     muxer_write_chunk(mux_v, mpi->width*mpi->height*mux_v->bih->biBitCount/8, 0x10, pts, pts);
 146     return 1;
 147 }
 148
 149 //===========================================================================//
 150
 151 static int vf_open(vf_instance_t *vf, char* args){
 152     vf->config = config;
 153     vf->default_caps = VFCAP_CONSTANT;
 154     vf->control = control;
 155     vf->query_format = query_format;
 156     vf->put_image = put_image;
 157     vf->default_caps = 0;
 158     vf->priv = malloc(sizeof(struct vf_priv_s));
 159     memset(vf->priv, 0, sizeof(struct vf_priv_s));
 160     vf->priv->mux = (muxer_stream_t*)args;
 161
 162     mux_v->bih = calloc(1, sizeof(BITMAPINFOHEADER));
 163     mux_v->bih->biSize = sizeof(BITMAPINFOHEADER);
 164     mux_v->bih->biWidth = 0;
 165     mux_v->bih->biHeight = 0;
 166
 167     return 1;
 168 }
 169
 170 vf_info_t ve_info_raw = {
 171     "raw encoder",
 172     "raw",
 173     "jwe21@cam.ac.uk",
 174     "Based on rawrgb",
 175     vf_open
 176 };
 177
 178 //===========================================================================//