33d5c077302d4264e37d8a481919b03e061098ed
[ffmpeg.git] / libavfilter / libmpcodecs / mp_image.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 "config.h"
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25 #if HAVE_MALLOC_H
26 #include <malloc.h>
27 #endif
28
29 #include "img_format.h"
30 #include "mp_image.h"
31
32 #include "libvo/fastmemcpy.h"
33 //#include "libavutil/mem.h"
34
35 void ff_mp_image_alloc_planes(mp_image_t *mpi) {
36   // IF09 - allocate space for 4. plane delta info - unused
37   if (mpi->imgfmt == IMGFMT_IF09) {
38     mpi->planes[0]=av_malloc(mpi->bpp*mpi->width*(mpi->height+2)/8+
39                             mpi->chroma_width*mpi->chroma_height);
40   } else
41     mpi->planes[0]=av_malloc(mpi->bpp*mpi->width*(mpi->height+2)/8);
42   if (mpi->flags&MP_IMGFLAG_PLANAR) {
43     int bpp = IMGFMT_IS_YUVP16(mpi->imgfmt)? 2 : 1;
44     // YV12/I420/YVU9/IF09. feel free to add other planar formats here...
45     mpi->stride[0]=mpi->stride[3]=bpp*mpi->width;
46     if(mpi->num_planes > 2){
47       mpi->stride[1]=mpi->stride[2]=bpp*mpi->chroma_width;
48       if(mpi->flags&MP_IMGFLAG_SWAPPED){
49         // I420/IYUV  (Y,U,V)
50         mpi->planes[1]=mpi->planes[0]+mpi->stride[0]*mpi->height;
51         mpi->planes[2]=mpi->planes[1]+mpi->stride[1]*mpi->chroma_height;
52         if (mpi->num_planes > 3)
53             mpi->planes[3]=mpi->planes[2]+mpi->stride[2]*mpi->chroma_height;
54       } else {
55         // YV12,YVU9,IF09  (Y,V,U)
56         mpi->planes[2]=mpi->planes[0]+mpi->stride[0]*mpi->height;
57         mpi->planes[1]=mpi->planes[2]+mpi->stride[1]*mpi->chroma_height;
58         if (mpi->num_planes > 3)
59             mpi->planes[3]=mpi->planes[1]+mpi->stride[1]*mpi->chroma_height;
60       }
61     } else {
62       // NV12/NV21
63       mpi->stride[1]=mpi->chroma_width;
64       mpi->planes[1]=mpi->planes[0]+mpi->stride[0]*mpi->height;
65     }
66   } else {
67     mpi->stride[0]=mpi->width*mpi->bpp/8;
68     if (mpi->flags & MP_IMGFLAG_RGB_PALETTE)
69       mpi->planes[1] = av_malloc(1024);
70   }
71   mpi->flags|=MP_IMGFLAG_ALLOCATED;
72 }
73
74 mp_image_t* ff_alloc_mpi(int w, int h, unsigned long int fmt) {
75   mp_image_t* mpi = ff_new_mp_image(w,h);
76
77   ff_mp_image_setfmt(mpi,fmt);
78   ff_mp_image_alloc_planes(mpi);
79
80   return mpi;
81 }
82
83 void ff_copy_mpi(mp_image_t *dmpi, mp_image_t *mpi) {
84   if(mpi->flags&MP_IMGFLAG_PLANAR){
85     memcpy_pic(dmpi->planes[0],mpi->planes[0], mpi->w, mpi->h,
86                dmpi->stride[0],mpi->stride[0]);
87     memcpy_pic(dmpi->planes[1],mpi->planes[1], mpi->chroma_width, mpi->chroma_height,
88                dmpi->stride[1],mpi->stride[1]);
89     memcpy_pic(dmpi->planes[2], mpi->planes[2], mpi->chroma_width, mpi->chroma_height,
90                dmpi->stride[2],mpi->stride[2]);
91   } else {
92     memcpy_pic(dmpi->planes[0],mpi->planes[0],
93                mpi->w*(dmpi->bpp/8), mpi->h,
94                dmpi->stride[0],mpi->stride[0]);
95   }
96 }
97
98 void ff_mp_image_setfmt(mp_image_t* mpi,unsigned int out_fmt){
99     mpi->flags&=~(MP_IMGFLAG_PLANAR|MP_IMGFLAG_YUV|MP_IMGFLAG_SWAPPED);
100     mpi->imgfmt=out_fmt;
101     // compressed formats
102     if(out_fmt == IMGFMT_MPEGPES ||
103        out_fmt == IMGFMT_ZRMJPEGNI || out_fmt == IMGFMT_ZRMJPEGIT || out_fmt == IMGFMT_ZRMJPEGIB ||
104        IMGFMT_IS_HWACCEL(out_fmt)){
105         mpi->bpp=0;
106         return;
107     }
108     mpi->num_planes=1;
109     if (IMGFMT_IS_RGB(out_fmt)) {
110         if (IMGFMT_RGB_DEPTH(out_fmt) < 8 && !(out_fmt&128))
111             mpi->bpp = IMGFMT_RGB_DEPTH(out_fmt);
112         else
113             mpi->bpp=(IMGFMT_RGB_DEPTH(out_fmt)+7)&(~7);
114         return;
115     }
116     if (IMGFMT_IS_BGR(out_fmt)) {
117         if (IMGFMT_BGR_DEPTH(out_fmt) < 8 && !(out_fmt&128))
118             mpi->bpp = IMGFMT_BGR_DEPTH(out_fmt);
119         else
120             mpi->bpp=(IMGFMT_BGR_DEPTH(out_fmt)+7)&(~7);
121         mpi->flags|=MP_IMGFLAG_SWAPPED;
122         return;
123     }
124     mpi->num_planes=3;
125     if (out_fmt == IMGFMT_GBR24P) {
126         mpi->bpp=24;
127         mpi->flags|=MP_IMGFLAG_PLANAR;
128         return;
129     } else if (out_fmt == IMGFMT_GBR12P) {
130         mpi->bpp=36;
131         mpi->flags|=MP_IMGFLAG_PLANAR;
132         return;
133     } else if (out_fmt == IMGFMT_GBR14P) {
134         mpi->bpp=42;
135         mpi->flags|=MP_IMGFLAG_PLANAR;
136         return;
137     }
138     mpi->flags|=MP_IMGFLAG_YUV;
139     if (ff_mp_get_chroma_shift(out_fmt, NULL, NULL, NULL)) {
140         mpi->flags|=MP_IMGFLAG_PLANAR;
141         mpi->bpp = ff_mp_get_chroma_shift(out_fmt, &mpi->chroma_x_shift, &mpi->chroma_y_shift, NULL);
142         mpi->chroma_width  = mpi->width  >> mpi->chroma_x_shift;
143         mpi->chroma_height = mpi->height >> mpi->chroma_y_shift;
144     }
145     switch(out_fmt){
146     case IMGFMT_I420:
147     case IMGFMT_IYUV:
148         mpi->flags|=MP_IMGFLAG_SWAPPED;
149     case IMGFMT_YV12:
150         return;
151     case IMGFMT_420A:
152     case IMGFMT_422A:
153     case IMGFMT_444A:
154     case IMGFMT_IF09:
155         mpi->num_planes=4;
156     case IMGFMT_YVU9:
157     case IMGFMT_444P:
158     case IMGFMT_422P:
159     case IMGFMT_411P:
160     case IMGFMT_440P:
161     case IMGFMT_444P16_LE:
162     case IMGFMT_444P16_BE:
163     case IMGFMT_444P14_LE:
164     case IMGFMT_444P14_BE:
165     case IMGFMT_444P12_LE:
166     case IMGFMT_444P12_BE:
167     case IMGFMT_444P10_LE:
168     case IMGFMT_444P10_BE:
169     case IMGFMT_444P9_LE:
170     case IMGFMT_444P9_BE:
171     case IMGFMT_422P16_LE:
172     case IMGFMT_422P16_BE:
173     case IMGFMT_422P14_LE:
174     case IMGFMT_422P14_BE:
175     case IMGFMT_422P12_LE:
176     case IMGFMT_422P12_BE:
177     case IMGFMT_422P10_LE:
178     case IMGFMT_422P10_BE:
179     case IMGFMT_422P9_LE:
180     case IMGFMT_422P9_BE:
181     case IMGFMT_420P16_LE:
182     case IMGFMT_420P16_BE:
183     case IMGFMT_420P14_LE:
184     case IMGFMT_420P14_BE:
185     case IMGFMT_420P12_LE:
186     case IMGFMT_420P12_BE:
187     case IMGFMT_420P10_LE:
188     case IMGFMT_420P10_BE:
189     case IMGFMT_420P9_LE:
190     case IMGFMT_420P9_BE:
191         return;
192     case IMGFMT_Y16_LE:
193     case IMGFMT_Y16_BE:
194         mpi->bpp=16;
195     case IMGFMT_Y800:
196     case IMGFMT_Y8:
197         /* they're planar ones, but for easier handling use them as packed */
198         mpi->flags&=~MP_IMGFLAG_PLANAR;
199         mpi->num_planes=1;
200         return;
201     case IMGFMT_Y8A:
202         mpi->num_planes=2;
203         return;
204     case IMGFMT_UYVY:
205         mpi->flags|=MP_IMGFLAG_SWAPPED;
206     case IMGFMT_YUY2:
207         mpi->chroma_x_shift = 1;
208         mpi->bpp=16;
209         mpi->num_planes=1;
210         return;
211     case IMGFMT_NV12:
212         mpi->flags|=MP_IMGFLAG_SWAPPED;
213     case IMGFMT_NV21:
214         mpi->flags|=MP_IMGFLAG_PLANAR;
215         mpi->bpp=12;
216         mpi->num_planes=2;
217         mpi->chroma_width=(mpi->width>>0);
218         mpi->chroma_height=(mpi->height>>1);
219         mpi->chroma_x_shift=0;
220         mpi->chroma_y_shift=1;
221         return;
222     }
223     ff_mp_msg(MSGT_DECVIDEO,MSGL_WARN,"mp_image: unknown out_fmt: 0x%X\n",out_fmt);
224     mpi->bpp=0;
225 }
226
227 mp_image_t* ff_new_mp_image(int w,int h){
228     mp_image_t* mpi = malloc(sizeof(mp_image_t));
229     if(!mpi) return NULL; // error!
230     memset(mpi,0,sizeof(mp_image_t));
231     mpi->width=mpi->w=w;
232     mpi->height=mpi->h=h;
233     return mpi;
234 }
235
236 void ff_free_mp_image(mp_image_t* mpi){
237     if(!mpi) return;
238     if(mpi->flags&MP_IMGFLAG_ALLOCATED){
239         /* becouse we allocate the whole image in once */
240         av_free(mpi->planes[0]);
241         if (mpi->flags & MP_IMGFLAG_RGB_PALETTE)
242             av_free(mpi->planes[1]);
243     }
244     free(mpi);
245 }
246