Update to MPlayer SVN rev 34578.
[vaapi:athaifas-mplayer.git] / 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 "libmpcodecs/img_format.h"
30 #include "libmpcodecs/mp_image.h"
31 #include "libvo/fastmemcpy.h"
32 #include "libavutil/mem.h"
33 #include "mp_msg.h"
34
35 void 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* alloc_mpi(int w, int h, unsigned long int fmt) {
75   mp_image_t* mpi = new_mp_image(w,h);
76
77   mp_image_setfmt(mpi,fmt);
78   mp_image_alloc_planes(mpi);
79
80   return mpi;
81 }
82
83 void 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 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     }
130     mpi->flags|=MP_IMGFLAG_YUV;
131     if (mp_get_chroma_shift(out_fmt, NULL, NULL, NULL)) {
132         mpi->flags|=MP_IMGFLAG_PLANAR;
133         mpi->bpp = mp_get_chroma_shift(out_fmt, &mpi->chroma_x_shift, &mpi->chroma_y_shift, NULL);
134         mpi->chroma_width  = mpi->width  >> mpi->chroma_x_shift;
135         mpi->chroma_height = mpi->height >> mpi->chroma_y_shift;
136     }
137     switch(out_fmt){
138     case IMGFMT_I420:
139     case IMGFMT_IYUV:
140         mpi->flags|=MP_IMGFLAG_SWAPPED;
141     case IMGFMT_YV12:
142         return;
143     case IMGFMT_420A:
144     case IMGFMT_IF09:
145         mpi->num_planes=4;
146     case IMGFMT_YVU9:
147     case IMGFMT_444P:
148     case IMGFMT_422P:
149     case IMGFMT_411P:
150     case IMGFMT_440P:
151     case IMGFMT_444P16_LE:
152     case IMGFMT_444P16_BE:
153     case IMGFMT_444P10_LE:
154     case IMGFMT_444P10_BE:
155     case IMGFMT_444P9_LE:
156     case IMGFMT_444P9_BE:
157     case IMGFMT_422P16_LE:
158     case IMGFMT_422P16_BE:
159     case IMGFMT_422P10_LE:
160     case IMGFMT_422P10_BE:
161     case IMGFMT_422P9_LE:
162     case IMGFMT_422P9_BE:
163     case IMGFMT_420P16_LE:
164     case IMGFMT_420P16_BE:
165     case IMGFMT_420P10_LE:
166     case IMGFMT_420P10_BE:
167     case IMGFMT_420P9_LE:
168     case IMGFMT_420P9_BE:
169         return;
170     case IMGFMT_Y800:
171     case IMGFMT_Y8:
172         /* they're planar ones, but for easier handling use them as packed */
173         mpi->flags&=~MP_IMGFLAG_PLANAR;
174         mpi->num_planes=1;
175         return;
176     case IMGFMT_UYVY:
177         mpi->flags|=MP_IMGFLAG_SWAPPED;
178     case IMGFMT_YUY2:
179         mpi->chroma_x_shift = 1;
180         mpi->bpp=16;
181         mpi->num_planes=1;
182         return;
183     case IMGFMT_NV12:
184         mpi->flags|=MP_IMGFLAG_SWAPPED;
185     case IMGFMT_NV21:
186         mpi->flags|=MP_IMGFLAG_PLANAR;
187         mpi->bpp=12;
188         mpi->num_planes=2;
189         mpi->chroma_width=(mpi->width>>0);
190         mpi->chroma_height=(mpi->height>>1);
191         mpi->chroma_x_shift=0;
192         mpi->chroma_y_shift=1;
193         return;
194     }
195     mp_msg(MSGT_DECVIDEO,MSGL_WARN,"mp_image: unknown out_fmt: 0x%X\n",out_fmt);
196     mpi->bpp=0;
197 }
198
199 mp_image_t* new_mp_image(int w,int h){
200     mp_image_t* mpi = malloc(sizeof(mp_image_t));
201     if(!mpi) return NULL; // error!
202     memset(mpi,0,sizeof(mp_image_t));
203     mpi->width=mpi->w=w;
204     mpi->height=mpi->h=h;
205     return mpi;
206 }
207
208 void free_mp_image(mp_image_t* mpi){
209     if(!mpi) return;
210     if(mpi->flags&MP_IMGFLAG_ALLOCATED){
211         /* becouse we allocate the whole image in once */
212         av_free(mpi->planes[0]);
213         if (mpi->flags & MP_IMGFLAG_RGB_PALETTE)
214             av_free(mpi->planes[1]);
215     }
216     free(mpi);
217 }
218