fate: add more tests for hue video filter
[ffmpeg.git] / libavcodec / mpegutils.c
1 /*
2  * Mpeg video formats-related defines and utility functions
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdint.h>
22
23 #include "libavutil/common.h"
24 #include "libavutil/frame.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/motion_vector.h"
27 #include "libavutil/avassert.h"
28
29 #include "avcodec.h"
30 #include "mpegutils.h"
31
32 static int add_mb(AVMotionVector *mb, uint32_t mb_type,
33                   int dst_x, int dst_y,
34                   int motion_x, int motion_y, int motion_scale,
35                   int direction)
36 {
37     mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
38     mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
39     mb->motion_x = motion_x;
40     mb->motion_y = motion_y;
41     mb->motion_scale = motion_scale;
42     mb->dst_x = dst_x;
43     mb->dst_y = dst_y;
44     mb->src_x = dst_x + motion_x / motion_scale;
45     mb->src_y = dst_y + motion_y / motion_scale;
46     mb->source = direction ? 1 : -1;
47     mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
48     return 1;
49 }
50
51 void ff_draw_horiz_band(AVCodecContext *avctx,
52                         AVFrame *cur, AVFrame *last,
53                         int y, int h, int picture_structure,
54                         int first_field, int low_delay)
55 {
56     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
57     int vshift = desc->log2_chroma_h;
58     const int field_pic = picture_structure != PICT_FRAME;
59     if (field_pic) {
60         h <<= 1;
61         y <<= 1;
62     }
63
64     h = FFMIN(h, avctx->height - y);
65
66     if (field_pic && first_field &&
67         !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
68         return;
69
70     if (avctx->draw_horiz_band) {
71         AVFrame *src;
72         int offset[AV_NUM_DATA_POINTERS];
73         int i;
74
75         if (cur->pict_type == AV_PICTURE_TYPE_B || low_delay ||
76            (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
77             src = cur;
78         else if (last)
79             src = last;
80         else
81             return;
82
83         if (cur->pict_type == AV_PICTURE_TYPE_B &&
84             picture_structure == PICT_FRAME &&
85             avctx->codec_id != AV_CODEC_ID_SVQ3) {
86             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
87                 offset[i] = 0;
88         } else {
89             offset[0]= y * src->linesize[0];
90             offset[1]=
91             offset[2]= (y >> vshift) * src->linesize[1];
92             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
93                 offset[i] = 0;
94         }
95
96         emms_c();
97
98         avctx->draw_horiz_band(avctx, src, offset,
99                                y, picture_structure, h);
100     }
101 }
102
103 void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
104                          uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
105                          int *low_delay,
106                          int mb_width, int mb_height, int mb_stride, int quarter_sample)
107 {
108     if ((avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) && mbtype_table && motion_val[0]) {
109         const int shift = 1 + quarter_sample;
110         const int scale = 1 << shift;
111         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
112         const int mv_stride      = (mb_width << mv_sample_log2) +
113                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
114         int mb_x, mb_y, mbcount = 0;
115
116         /* size is width * height * 2 * 4 where 2 is for directions and 4 is
117          * for the maximum number of MB (4 MB in case of IS_8x8) */
118         AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
119         if (!mvs)
120             return;
121
122         for (mb_y = 0; mb_y < mb_height; mb_y++) {
123             for (mb_x = 0; mb_x < mb_width; mb_x++) {
124                 int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
125                 for (direction = 0; direction < 2; direction++) {
126                     if (!USES_LIST(mb_type, direction))
127                         continue;
128                     if (IS_8X8(mb_type)) {
129                         for (i = 0; i < 4; i++) {
130                             int sx = mb_x * 16 + 4 + 8 * (i & 1);
131                             int sy = mb_y * 16 + 4 + 8 * (i >> 1);
132                             int xy = (mb_x * 2 + (i & 1) +
133                                       (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
134                             int mx = motion_val[direction][xy][0];
135                             int my = motion_val[direction][xy][1];
136                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
137                         }
138                     } else if (IS_16X8(mb_type)) {
139                         for (i = 0; i < 2; i++) {
140                             int sx = mb_x * 16 + 8;
141                             int sy = mb_y * 16 + 4 + 8 * i;
142                             int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
143                             int mx = motion_val[direction][xy][0];
144                             int my = motion_val[direction][xy][1];
145
146                             if (IS_INTERLACED(mb_type))
147                                 my *= 2;
148
149                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
150                         }
151                     } else if (IS_8X16(mb_type)) {
152                         for (i = 0; i < 2; i++) {
153                             int sx = mb_x * 16 + 4 + 8 * i;
154                             int sy = mb_y * 16 + 8;
155                             int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
156                             int mx = motion_val[direction][xy][0];
157                             int my = motion_val[direction][xy][1];
158
159                             if (IS_INTERLACED(mb_type))
160                                 my *= 2;
161
162                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
163                         }
164                     } else {
165                           int sx = mb_x * 16 + 8;
166                           int sy = mb_y * 16 + 8;
167                           int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
168                           int mx = motion_val[direction][xy][0];
169                           int my = motion_val[direction][xy][1];
170                           mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
171                     }
172                 }
173             }
174         }
175
176         if (mbcount) {
177             AVFrameSideData *sd;
178
179             av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
180             sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
181             if (!sd) {
182                 av_freep(&mvs);
183                 return;
184             }
185             memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
186         }
187
188         av_freep(&mvs);
189     }
190
191     /* TODO: export all the following to make them accessible for users (and filters) */
192     if (avctx->hwaccel || !mbtype_table)
193         return;
194
195
196     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
197         int x,y;
198
199         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
200                av_get_picture_type_char(pict->pict_type));
201         for (y = 0; y < mb_height; y++) {
202             for (x = 0; x < mb_width; x++) {
203                 if (avctx->debug & FF_DEBUG_SKIP) {
204                     int count = mbskip_table ? mbskip_table[x + y * mb_stride] : 0;
205                     if (count > 9)
206                         count = 9;
207                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);
208                 }
209                 if (avctx->debug & FF_DEBUG_QP) {
210                     av_log(avctx, AV_LOG_DEBUG, "%2d",
211                            qscale_table[x + y * mb_stride]);
212                 }
213                 if (avctx->debug & FF_DEBUG_MB_TYPE) {
214                     int mb_type = mbtype_table[x + y * mb_stride];
215                     // Type & MV direction
216                     if (IS_PCM(mb_type))
217                         av_log(avctx, AV_LOG_DEBUG, "P");
218                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
219                         av_log(avctx, AV_LOG_DEBUG, "A");
220                     else if (IS_INTRA4x4(mb_type))
221                         av_log(avctx, AV_LOG_DEBUG, "i");
222                     else if (IS_INTRA16x16(mb_type))
223                         av_log(avctx, AV_LOG_DEBUG, "I");
224                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
225                         av_log(avctx, AV_LOG_DEBUG, "d");
226                     else if (IS_DIRECT(mb_type))
227                         av_log(avctx, AV_LOG_DEBUG, "D");
228                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
229                         av_log(avctx, AV_LOG_DEBUG, "g");
230                     else if (IS_GMC(mb_type))
231                         av_log(avctx, AV_LOG_DEBUG, "G");
232                     else if (IS_SKIP(mb_type))
233                         av_log(avctx, AV_LOG_DEBUG, "S");
234                     else if (!USES_LIST(mb_type, 1))
235                         av_log(avctx, AV_LOG_DEBUG, ">");
236                     else if (!USES_LIST(mb_type, 0))
237                         av_log(avctx, AV_LOG_DEBUG, "<");
238                     else {
239                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
240                         av_log(avctx, AV_LOG_DEBUG, "X");
241                     }
242
243                     // segmentation
244                     if (IS_8X8(mb_type))
245                         av_log(avctx, AV_LOG_DEBUG, "+");
246                     else if (IS_16X8(mb_type))
247                         av_log(avctx, AV_LOG_DEBUG, "-");
248                     else if (IS_8X16(mb_type))
249                         av_log(avctx, AV_LOG_DEBUG, "|");
250                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
251                         av_log(avctx, AV_LOG_DEBUG, " ");
252                     else
253                         av_log(avctx, AV_LOG_DEBUG, "?");
254
255
256                     if (IS_INTERLACED(mb_type))
257                         av_log(avctx, AV_LOG_DEBUG, "=");
258                     else
259                         av_log(avctx, AV_LOG_DEBUG, " ");
260                 }
261             }
262             av_log(avctx, AV_LOG_DEBUG, "\n");
263         }
264     }
265
266 #if FF_API_DEBUG_MV
267     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
268         (avctx->debug_mv)) {
269         int mb_y;
270         int i, ret;
271         int h_chroma_shift, v_chroma_shift, block_height;
272         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
273         const int mv_stride      = (mb_width << mv_sample_log2) +
274                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
275
276         if (low_delay)
277             *low_delay = 0; // needed to see the vectors without trashing the buffers
278
279         ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
280         if (ret)
281             return ret;
282
283         av_frame_make_writable(pict);
284
285         pict->opaque = NULL;
286         block_height = 16 >> v_chroma_shift;
287
288         for (mb_y = 0; mb_y < mb_height; mb_y++) {
289             int mb_x;
290             for (mb_x = 0; mb_x < mb_width; mb_x++) {
291                 const int mb_index = mb_x + mb_y * mb_stride;
292                 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
293                     uint64_t c = (qscale_table[mb_index] * 128 / 31) *
294                                  0x0101010101010101ULL;
295                     int y;
296                     for (y = 0; y < block_height; y++) {
297                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
298                                       (block_height * mb_y + y) *
299                                       pict->linesize[1]) = c;
300                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
301                                       (block_height * mb_y + y) *
302                                       pict->linesize[2]) = c;
303                     }
304                 }
305                 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
306                     motion_val[0]) {
307                     int mb_type = mbtype_table[mb_index];
308                     uint64_t u,v;
309                     int y;
310 #define COLOR(theta, r) \
311     u = (int)(128 + r * cos(theta * M_PI / 180)); \
312     v = (int)(128 + r * sin(theta * M_PI / 180));
313
314
315                     u = v = 128;
316                     if (IS_PCM(mb_type)) {
317                         COLOR(120, 48)
318                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
319                                IS_INTRA16x16(mb_type)) {
320                         COLOR(30, 48)
321                     } else if (IS_INTRA4x4(mb_type)) {
322                         COLOR(90, 48)
323                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
324                         // COLOR(120, 48)
325                     } else if (IS_DIRECT(mb_type)) {
326                         COLOR(150, 48)
327                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
328                         COLOR(170, 48)
329                     } else if (IS_GMC(mb_type)) {
330                         COLOR(190, 48)
331                     } else if (IS_SKIP(mb_type)) {
332                         // COLOR(180, 48)
333                     } else if (!USES_LIST(mb_type, 1)) {
334                         COLOR(240, 48)
335                     } else if (!USES_LIST(mb_type, 0)) {
336                         COLOR(0, 48)
337                     } else {
338                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
339                         COLOR(300,48)
340                     }
341
342                     u *= 0x0101010101010101ULL;
343                     v *= 0x0101010101010101ULL;
344                     for (y = 0; y < block_height; y++) {
345                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
346                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
347                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
348                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
349                     }
350
351                     // segmentation
352                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
353                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
354                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
355                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
356                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
357                     }
358                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
359                         for (y = 0; y < 16; y++)
360                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
361                                           pict->linesize[0]] ^= 0x80;
362                     }
363                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
364                         int dm = 1 << (mv_sample_log2 - 2);
365                         for (i = 0; i < 4; i++) {
366                             int sx = mb_x * 16 + 8 * (i & 1);
367                             int sy = mb_y * 16 + 8 * (i >> 1);
368                             int xy = (mb_x * 2 + (i & 1) +
369                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
370                             // FIXME bidir
371                             int32_t *mv = (int32_t *) &motion_val[0][xy];
372                             if (mv[0] != mv[dm] ||
373                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
374                                 for (y = 0; y < 8; y++)
375                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
376                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
377                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
378                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
379                         }
380                     }
381
382                     if (IS_INTERLACED(mb_type) &&
383                         avctx->codec->id == AV_CODEC_ID_H264) {
384                         // hmm
385                     }
386                 }
387                 if (mbskip_table)
388                     mbskip_table[mb_index] = 0;
389             }
390         }
391     }
392 #endif
393 }