/* GStreamer

 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>

 * This file:

 * Copyright (c) 2002-2004 Ronald Bultje <rbultje@ronald.bitfreak.net>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <gst/gst.h>

#include "avcodec.h"

#include "gstffmpegcodecmap.h"

static GstCaps *

gst_ff_vid_caps_new (AVCodecContext * context,

    const char *mimetype, const char *fieldname, ...)

    G_GNUC_NULL_TERMINATED;

     static GstCaps *gst_ff_aud_caps_new (AVCodecContext * context,

    const char *mimetype, const char *fieldname, ...) G_GNUC_NULL_TERMINATED;

/*

 * Read a palette from a caps.

 */

     static void

         gst_ffmpeg_get_palette (const GstCaps * caps, AVCodecContext * context)

{

  GstStructure *str = gst_caps_get_structure (caps, 0);

  const GValue *palette_v;

  /* do we have a palette? */

  if ((palette_v = gst_structure_get_value (str, "palette_data")) && context) {

    const GstBuffer *palette;

    palette = gst_value_get_buffer (palette_v);

    if (palette && GST_BUFFER_SIZE (palette) >= 256 * 4) {

      if (context->palctrl)

        av_free (context->palctrl);

      context->palctrl = av_malloc (sizeof (AVPaletteControl));

      context->palctrl->palette_changed = 1;

      memcpy (context->palctrl->palette, GST_BUFFER_DATA (palette),

          AVPALETTE_SIZE);

    }

  }

}

static void

gst_ffmpeg_set_palette (GstCaps * caps, AVCodecContext * context)

{

  if (context->palctrl) {

    GstBuffer *palette = gst_buffer_new_and_alloc (256 * 4);

    memcpy (GST_BUFFER_DATA (palette), context->palctrl->palette,

        AVPALETTE_SIZE);

    gst_caps_set_simple (caps, "palette_data", GST_TYPE_BUFFER, palette, NULL);

    gst_buffer_unref (palette);

  }

}

/* this function creates caps with fixed or unfixed width/height

 * properties depending on whether we've got a context.

 *

 * See below for why we use this.

 *

 * We should actually do this stuff at the end, like in riff-media.c,

 * but I'm too lazy today. Maybe later.

 */

static GstCaps *

gst_ff_vid_caps_new (AVCodecContext * context, const char *mimetype,

    const char *fieldname, ...)

{

  GstStructure *structure = NULL;

  GstCaps *caps = NULL;

  va_list var_args;

  if (context != NULL) {

    caps = gst_caps_new_simple (mimetype,

        "width", G_TYPE_INT, context->width,

        "height", G_TYPE_INT, context->height,

        "framerate", GST_TYPE_FRACTION,

        (gint) context->frame_rate, (gint) context->frame_rate_base, NULL);

  } else {

    caps = gst_caps_new_simple (mimetype,

        "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,

        "height", GST_TYPE_INT_RANGE, 1, G_MAXINT,

        "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);

  }

  structure = gst_caps_get_structure (caps, 0);

  if (structure) {

    va_start (var_args, fieldname);

    gst_structure_set_valist (structure, fieldname, var_args);

    va_end (var_args);

  }

  return caps;

}

/* same for audio - now with channels/sample rate

 */

static GstCaps *

gst_ff_aud_caps_new (AVCodecContext * context, const char *mimetype,

    const char *fieldname, ...)

{

  GstCaps *caps = NULL;

  GstStructure *structure = NULL;

  va_list var_args;

  if (context != NULL) {

    caps = gst_caps_new_simple (mimetype,

        "rate", G_TYPE_INT, context->sample_rate,

        "channels", G_TYPE_INT, context->channels, NULL);

  } else {

    caps = gst_caps_new_simple (mimetype, NULL);

  }

  structure = gst_caps_get_structure (caps, 0);

  if (structure) {

    va_start (var_args, fieldname);

    gst_structure_set_valist (structure, fieldname, var_args);

    va_end (var_args);

  }

  return caps;

}

/* Convert a FFMPEG Pixel Format and optional AVCodecContext

 * to a GstCaps. If the context is ommitted, no fixed values

 * for video/audio size will be included in the GstCaps

 *

 * See below for usefulness

 */

static GstCaps *

gst_ffmpeg_pixfmt_to_caps (enum PixelFormat pix_fmt, AVCodecContext * context)

{

  GstCaps *caps = NULL;

  int bpp = 0, depth = 0, endianness = 0;

  gulong g_mask = 0, r_mask = 0, b_mask = 0, a_mask = 0;

  guint32 fmt = 0;

  switch (pix_fmt) {

    case PIX_FMT_YUV420P:

      fmt = GST_MAKE_FOURCC ('I', '4', '2', '0');

      break;

    case PIX_FMT_YVU420P:

      fmt = GST_MAKE_FOURCC ('Y', 'V', '1', '2');

      break;

    case PIX_FMT_YUV422:

      fmt = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');

      break;

    case PIX_FMT_UYVY422:

      fmt = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');

      break;

    case PIX_FMT_UYVY411:

      fmt = GST_MAKE_FOURCC ('I', 'Y', 'U', '1');

      break;

    case PIX_FMT_RGB24:

      bpp = depth = 24;

      endianness = G_BIG_ENDIAN;

      r_mask = 0xff0000;

      g_mask = 0x00ff00;

      b_mask = 0x0000ff;

      break;

    case PIX_FMT_BGR24:

      bpp = depth = 24;

      endianness = G_BIG_ENDIAN;

      r_mask = 0x0000ff;

      g_mask = 0x00ff00;

      b_mask = 0xff0000;

      break;

    case PIX_FMT_YUV422P:

      fmt = GST_MAKE_FOURCC ('Y', '4', '2', 'B');

      break;

    case PIX_FMT_YUV444P:

      fmt = GST_MAKE_FOURCC ('Y', '4', '4', '4');

      break;

    case PIX_FMT_RGB32:

      bpp = 32;

      depth = 24;

      endianness = G_BIG_ENDIAN;

#if (G_BYTE_ORDER == G_BIG_ENDIAN)

      r_mask = 0x00ff0000;

      g_mask = 0x0000ff00;

      b_mask = 0x000000ff;

#else

      r_mask = 0x0000ff00;

      g_mask = 0x00ff0000;

      b_mask = 0xff000000;

#endif

      break;

    case PIX_FMT_BGR32:

      bpp = 32;

      depth = 24;

      endianness = G_BIG_ENDIAN;

#if (G_BYTE_ORDER == G_BIG_ENDIAN)

      r_mask = 0x0000ff00;

      g_mask = 0x00ff0000;

      b_mask = 0xff000000;

#else

      r_mask = 0x00ff0000;

      g_mask = 0x0000ff00;

      b_mask = 0x000000ff;

#endif

      break;

    case PIX_FMT_xRGB32:

      bpp = 32;

      depth = 24;

      endianness = G_BIG_ENDIAN;

#if (G_BYTE_ORDER == G_BIG_ENDIAN)

      r_mask = 0xff000000;

      g_mask = 0x00ff0000;

      b_mask = 0x0000ff00;

#else

      r_mask = 0x000000ff;

      g_mask = 0x0000ff00;

      b_mask = 0x00ff0000;

#endif

      break;

    case PIX_FMT_BGRx32:

      bpp = 32;

      depth = 24;

      endianness = G_BIG_ENDIAN;

#if (G_BYTE_ORDER == G_BIG_ENDIAN)

      r_mask = 0x000000ff;

      g_mask = 0x0000ff00;

      b_mask = 0x00ff0000;

#else

      r_mask = 0xff000000;

      g_mask = 0x00ff0000;

      b_mask = 0x0000ff00;

#endif

      break;

    case PIX_FMT_RGBA32:

      bpp = 32;

      depth = 32;

      endianness = G_BIG_ENDIAN;

#if (G_BYTE_ORDER == G_BIG_ENDIAN)

      r_mask = 0x00ff0000;

      g_mask = 0x0000ff00;

      b_mask = 0x000000ff;

      a_mask = 0xff000000;

#else

      r_mask = 0x0000ff00;

      g_mask = 0x00ff0000;

      b_mask = 0xff000000;

      a_mask = 0x000000ff;

#endif

      break;

    case PIX_FMT_BGRA32:

      bpp = 32;

      depth = 32;

      endianness = G_BIG_ENDIAN;

#if (G_BYTE_ORDER == G_BIG_ENDIAN)

      r_mask = 0x0000ff00;

      g_mask = 0x00ff0000;

      b_mask = 0xff000000;

      a_mask = 0x000000ff;

#else

      r_mask = 0x00ff0000;

      g_mask = 0x0000ff00;

      b_mask = 0x000000ff;

      a_mask = 0xff000000;

#endif

      break;

    case PIX_FMT_ARGB32:

      bpp = 32;

      depth = 32;

      endianness = G_BIG_ENDIAN;

#if (G_BYTE_ORDER == G_BIG_ENDIAN)

      r_mask = 0xff000000;

      g_mask = 0x00ff0000;

      b_mask = 0x0000ff00;

      a_mask = 0x000000ff;

#else

      r_mask = 0x000000ff;

      g_mask = 0x0000ff00;

      b_mask = 0x00ff0000;

      a_mask = 0xff000000;

#endif

      break;

    case PIX_FMT_ABGR32:

      bpp = 32;

      depth = 32;

      endianness = G_BIG_ENDIAN;

#if (G_BYTE_ORDER == G_BIG_ENDIAN)

      r_mask = 0x000000ff;

      g_mask = 0x0000ff00;

      b_mask = 0x00ff0000;

      a_mask = 0xff000000;

#else

      r_mask = 0xff000000;

      g_mask = 0x00ff0000;

      b_mask = 0x0000ff00;

      a_mask = 0x000000ff;

#endif

      break;

    case PIX_FMT_YUV410P:

      fmt = GST_MAKE_FOURCC ('Y', 'U', 'V', '9');

      break;

    case PIX_FMT_YVU410P:

      fmt = GST_MAKE_FOURCC ('Y', 'V', 'U', '9');

      break;

    case PIX_FMT_YUV411P:

      fmt = GST_MAKE_FOURCC ('Y', '4', '1', 'B');

      break;

    case PIX_FMT_RGB565:

      bpp = depth = 16;

      endianness = G_BYTE_ORDER;

      r_mask = 0xf800;

      g_mask = 0x07e0;

      b_mask = 0x001f;

      break;

    case PIX_FMT_RGB555:

      bpp = 16;

      depth = 15;

      endianness = G_BYTE_ORDER;

      r_mask = 0x7c00;

      g_mask = 0x03e0;

      b_mask = 0x001f;

      break;

    case PIX_FMT_PAL8:

      bpp = depth = 8;

      endianness = G_BYTE_ORDER;

      break;

    case PIX_FMT_AYUV4444:

      fmt = GST_MAKE_FOURCC ('A', 'Y', 'U', 'V');

      break;

      bpp = depth = 8;

      caps = gst_ff_vid_caps_new (context, "video/x-raw-gray",

          "bpp", G_TYPE_INT, bpp, "depth", G_TYPE_INT, depth, NULL);

      break;

    default:

      /* give up ... */

      break;

  }

  if (caps == NULL) {

    if (bpp != 0) {

      if (a_mask != 0) {

        caps = gst_ff_vid_caps_new (context, "video/x-raw-rgb",

            "bpp", G_TYPE_INT, bpp,

            "depth", G_TYPE_INT, depth,

            "red_mask", G_TYPE_INT, r_mask,

            "green_mask", G_TYPE_INT, g_mask,

            "blue_mask", G_TYPE_INT, b_mask,

            "alpha_mask", G_TYPE_INT, a_mask,

            "endianness", G_TYPE_INT, endianness, NULL);

      } else if (r_mask != 0) {

        caps = gst_ff_vid_caps_new (context, "video/x-raw-rgb",

            "bpp", G_TYPE_INT, bpp,

            "depth", G_TYPE_INT, depth,

            "red_mask", G_TYPE_INT, r_mask,

            "green_mask", G_TYPE_INT, g_mask,

            "blue_mask", G_TYPE_INT, b_mask,

            "endianness", G_TYPE_INT, endianness, NULL);

      } else {

        caps = gst_ff_vid_caps_new (context, "video/x-raw-rgb",

            "bpp", G_TYPE_INT, bpp,

            "depth", G_TYPE_INT, depth,

            "endianness", G_TYPE_INT, endianness, NULL);

          gst_ffmpeg_set_palette (caps, context);

        }

      }

    } else if (fmt) {

      caps = gst_ff_vid_caps_new (context, "video/x-raw-yuv",

          "format", GST_TYPE_FOURCC, fmt, NULL);

    }

  }

  if (caps != NULL) {

  } else {

    GST_LOG ("No caps found for pix_fmt=%d", pix_fmt);

  }

  return caps;

}

/* Convert a FFMPEG Sample Format and optional AVCodecContext

 * to a GstCaps. If the context is ommitted, no fixed values

 * for video/audio size will be included in the GstCaps

 *

 * See below for usefulness

 */

static GstCaps *

gst_ffmpeg_smpfmt_to_caps (enum SampleFormat sample_fmt,

    AVCodecContext * context)

{

  GstCaps *caps = NULL;

  int bpp = 0;

  gboolean signedness = FALSE;

  switch (sample_fmt) {

    case SAMPLE_FMT_S16:

      signedness = TRUE;

      bpp = 16;

      break;

    default:

      /* .. */

      break;

  }

  if (bpp) {

    caps = gst_ff_aud_caps_new (context, "audio/x-raw-int",

        "signed", G_TYPE_BOOLEAN, signedness,

        "endianness", G_TYPE_INT, G_BYTE_ORDER,

        "width", G_TYPE_INT, bpp, "depth", G_TYPE_INT, bpp, NULL);

  }

  if (caps != NULL) {

  } else {

    GST_LOG ("No caps found for sample_fmt=%d", sample_fmt);

  }

  return caps;

}

/* Convert a FFMPEG codec Type and optional AVCodecContext

 * to a GstCaps. If the context is ommitted, no fixed values

 * for video/audio size will be included in the GstCaps

 *

 * CodecType is primarily meant for uncompressed data GstCaps!

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstCaps *

gst_ffmpegcsp_codectype_to_caps (enum CodecType codec_type,

    AVCodecContext * context)

{

  GstCaps *caps;

  switch (codec_type) {

    case CODEC_TYPE_VIDEO:

      if (context) {

        caps = gst_ffmpeg_pixfmt_to_caps (context->pix_fmt,

            context->width == -1 ? NULL : context);

      } else {

        GstCaps *temp;

        enum PixelFormat i;

        caps = gst_caps_new_empty ();

        for (i = 0; i < PIX_FMT_NB; i++) {

          temp = gst_ffmpeg_pixfmt_to_caps (i, NULL);

          if (temp != NULL) {

            gst_caps_append (caps, temp);

          }

        }

      }

      break;

    case CODEC_TYPE_AUDIO:

      if (context) {

        caps = gst_ffmpeg_smpfmt_to_caps (context->sample_fmt, context);

      } else {

        GstCaps *temp;

        enum SampleFormat i;

        caps = gst_caps_new_empty ();

        for (i = 0; i <= SAMPLE_FMT_S16; i++) {

          temp = gst_ffmpeg_smpfmt_to_caps (i, NULL);

          if (temp != NULL) {

            gst_caps_append (caps, temp);

          }

        }

      }

      break;

    default:

      /* .. */

      caps = NULL;

      break;

  }

  return caps;

}

/* Convert a GstCaps (audio/raw) to a FFMPEG SampleFmt

 * and other audio properties in a AVCodecContext.

 *

 * For usefulness, see below

 */

static void

gst_ffmpeg_caps_to_smpfmt (const GstCaps * caps,

    AVCodecContext * context, gboolean raw)

{

  GstStructure *structure;