gst/rtp/gstrtpvrawpay.c

   1 /* GStreamer
   2  * Copyright (C) <2008> Wim Taymans <wim.taymans@gmail.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include <string.h>
  25
  26 #include <gst/rtp/gstrtpbuffer.h>
  27
  28 #include "gstrtpvrawpay.h"
  29
  30 GST_DEBUG_CATEGORY_STATIC (rtpvrawpay_debug);
  31 #define GST_CAT_DEFAULT (rtpvrawpay_debug)
  32
  33 static GstStaticPadTemplate gst_rtp_vraw_pay_sink_template =
  34     GST_STATIC_PAD_TEMPLATE ("sink",
  35     GST_PAD_SINK,
  36     GST_PAD_ALWAYS,
  37     GST_STATIC_CAPS ("video/x-raw, "
  38         "format = (string) { RGB, RGBA, BGR, BGRA, AYUV, UYVY, I420, Y41B, UYVP }, "
  39         "width = (int) [ 1, 32767 ], " "height = (int) [ 1, 32767 ]; ")
  40     );
  41
  42 static GstStaticPadTemplate gst_rtp_vraw_pay_src_template =
  43 GST_STATIC_PAD_TEMPLATE ("src",
  44     GST_PAD_SRC,
  45     GST_PAD_ALWAYS,
  46     GST_STATIC_CAPS ("application/x-rtp, "
  47         "media = (string) \"video\", "
  48         "payload = (int) " GST_RTP_PAYLOAD_DYNAMIC_STRING ", "
  49         "clock-rate = (int) 90000, "
  50         "encoding-name = (string) \"RAW\","
  51         "sampling = (string) { \"RGB\", \"RGBA\", \"BGR\", \"BGRA\", "
  52         "\"YCbCr-4:4:4\", \"YCbCr-4:2:2\", \"YCbCr-4:2:0\", "
  53         "\"YCbCr-4:1:1\" },"
  54         /* we cannot express these as strings
  55          * "width = (string) [1 32767],"
  56          * "height = (string) [1 32767],"
  57          */
  58         "depth = (string) { \"8\", \"10\", \"12\", \"16\" },"
  59         "colorimetry = (string) { \"BT601-5\", \"BT709-2\", \"SMPTE240M\" }"
  60         /* optional
  61          * interlace =
  62          * top-field-first =
  63          * chroma-position = (string)
  64          * gamma = (float)
  65          */
  66     )
  67     );
  68
  69 static gboolean gst_rtp_vraw_pay_setcaps (GstRTPBasePayload * payload,
  70     GstCaps * caps);
  71 static GstFlowReturn gst_rtp_vraw_pay_handle_buffer (GstRTPBasePayload *
  72     payload, GstBuffer * buffer);
  73
  74 G_DEFINE_TYPE (GstRtpVRawPay, gst_rtp_vraw_pay, GST_TYPE_RTP_BASE_PAYLOAD)
  75
  76      static void gst_rtp_vraw_pay_class_init (GstRtpVRawPayClass * klass)
  77 {
  78   GstRTPBasePayloadClass *gstrtpbasepayload_class;
  79   GstElementClass *gstelement_class;
  80
  81   gstelement_class = (GstElementClass *) klass;
  82   gstrtpbasepayload_class = (GstRTPBasePayloadClass *) klass;
  83
  84   gstrtpbasepayload_class->set_caps = gst_rtp_vraw_pay_setcaps;
  85   gstrtpbasepayload_class->handle_buffer = gst_rtp_vraw_pay_handle_buffer;
  86
  87   gst_element_class_add_pad_template (gstelement_class,
  88       gst_static_pad_template_get (&gst_rtp_vraw_pay_src_template));
  89   gst_element_class_add_pad_template (gstelement_class,
  90       gst_static_pad_template_get (&gst_rtp_vraw_pay_sink_template));
  91
  92   gst_element_class_set_static_metadata (gstelement_class,
  93       "RTP Raw Video payloader", "Codec/Payloader/Network/RTP",
  94       "Payload raw video as RTP packets (RFC 4175)",
  95       "Wim Taymans <wim.taymans@gmail.com>");
  96
  97   GST_DEBUG_CATEGORY_INIT (rtpvrawpay_debug, "rtpvrawpay", 0,
  98       "Raw video RTP Payloader");
  99 }
 100
 101 static void
 102 gst_rtp_vraw_pay_init (GstRtpVRawPay * rtpvrawpay)
 103 {
 104 }
 105
 106 static gboolean
 107 gst_rtp_vraw_pay_setcaps (GstRTPBasePayload * payload, GstCaps * caps)
 108 {
 109   GstRtpVRawPay *rtpvrawpay;
 110   gboolean res;
 111   gint pgroup, xinc, yinc;
 112   const gchar *depthstr, *samplingstr, *colorimetrystr;
 113   gchar *wstr, *hstr;
 114   gint depth;
 115   GstVideoInfo info;
 116
 117   rtpvrawpay = GST_RTP_VRAW_PAY (payload);
 118
 119   if (!gst_video_info_from_caps (&info, caps))
 120     goto invalid_caps;
 121
 122   rtpvrawpay->vinfo = info;
 123
 124   if (gst_video_colorimetry_matches (&info.colorimetry,
 125           GST_VIDEO_COLORIMETRY_BT601)) {
 126     colorimetrystr = "BT601-5";
 127   } else if (gst_video_colorimetry_matches (&info.colorimetry,
 128           GST_VIDEO_COLORIMETRY_BT709)) {
 129     colorimetrystr = "BT709-2";
 130   } else if (gst_video_colorimetry_matches (&info.colorimetry,
 131           GST_VIDEO_COLORIMETRY_SMPTE240M)) {
 132     colorimetrystr = "SMPTE240M";
 133   } else {
 134     colorimetrystr = "SMPTE240M";
 135   }
 136
 137   xinc = yinc = 1;
 138
 139   /* these values are the only thing we can do */
 140   depthstr = "8";
 141   depth = 8;
 142
 143   switch (GST_VIDEO_INFO_FORMAT (&info)) {
 144     case GST_VIDEO_FORMAT_RGBA:
 145       samplingstr = "RGBA";
 146       pgroup = 4;
 147       break;
 148     case GST_VIDEO_FORMAT_BGRA:
 149       samplingstr = "BGRA";
 150       pgroup = 4;
 151       break;
 152     case GST_VIDEO_FORMAT_RGB:
 153       samplingstr = "RGB";
 154       pgroup = 3;
 155       break;
 156     case GST_VIDEO_FORMAT_BGR:
 157       samplingstr = "BGR";
 158       pgroup = 3;
 159       break;
 160     case GST_VIDEO_FORMAT_AYUV:
 161       samplingstr = "YCbCr-4:4:4";
 162       pgroup = 3;
 163       break;
 164     case GST_VIDEO_FORMAT_UYVY:
 165       samplingstr = "YCbCr-4:2:2";
 166       pgroup = 4;
 167       xinc = 2;
 168       break;
 169     case GST_VIDEO_FORMAT_Y41B:
 170       samplingstr = "YCbCr-4:1:1";
 171       pgroup = 6;
 172       xinc = 4;
 173       break;
 174     case GST_VIDEO_FORMAT_I420:
 175       samplingstr = "YCbCr-4:2:0";
 176       pgroup = 6;
 177       xinc = yinc = 2;
 178       break;
 179     case GST_VIDEO_FORMAT_UYVP:
 180       samplingstr = "YCbCr-4:2:2";
 181       pgroup = 5;
 182       xinc = 2;
 183       depth = 10;
 184       depthstr = "10";
 185       break;
 186     default:
 187       goto unknown_format;
 188       break;
 189   }
 190
 191   if (GST_VIDEO_INFO_IS_INTERLACED (&info)) {
 192     yinc *= 2;
 193   }
 194
 195   rtpvrawpay->pgroup = pgroup;
 196   rtpvrawpay->xinc = xinc;
 197   rtpvrawpay->yinc = yinc;
 198   rtpvrawpay->depth = depth;
 199
 200   GST_DEBUG_OBJECT (payload, "width %d, height %d, sampling %s",
 201       GST_VIDEO_INFO_WIDTH (&info), GST_VIDEO_INFO_HEIGHT (&info), samplingstr);
 202   GST_DEBUG_OBJECT (payload, "xinc %d, yinc %d, pgroup %d", xinc, yinc, pgroup);
 203
 204   wstr = g_strdup_printf ("%d", GST_VIDEO_INFO_WIDTH (&info));
 205   hstr = g_strdup_printf ("%d", GST_VIDEO_INFO_HEIGHT (&info));
 206
 207   gst_rtp_base_payload_set_options (payload, "video", TRUE, "RAW", 90000);
 208   if (GST_VIDEO_INFO_IS_INTERLACED (&info)) {
 209     res = gst_rtp_base_payload_set_outcaps (payload, "sampling", G_TYPE_STRING,
 210         samplingstr, "depth", G_TYPE_STRING, depthstr, "width", G_TYPE_STRING,
 211         wstr, "height", G_TYPE_STRING, hstr, "colorimetry", G_TYPE_STRING,
 212         colorimetrystr, "interlace", G_TYPE_STRING, "true", NULL);
 213   } else {
 214     res = gst_rtp_base_payload_set_outcaps (payload, "sampling", G_TYPE_STRING,
 215         samplingstr, "depth", G_TYPE_STRING, depthstr, "width", G_TYPE_STRING,
 216         wstr, "height", G_TYPE_STRING, hstr, "colorimetry", G_TYPE_STRING,
 217         colorimetrystr, NULL);
 218   }
 219   g_free (wstr);
 220   g_free (hstr);
 221
 222   return res;
 223
 224   /* ERRORS */
 225 invalid_caps:
 226   {
 227     GST_ERROR_OBJECT (payload, "could not parse caps");
 228     return FALSE;
 229   }
 230 unknown_format:
 231   {
 232     GST_ERROR_OBJECT (payload, "unknown caps format");
 233     return FALSE;
 234   }
 235 }
 236
 237 static GstFlowReturn
 238 gst_rtp_vraw_pay_handle_buffer (GstRTPBasePayload * payload, GstBuffer * buffer)
 239 {
 240   GstRtpVRawPay *rtpvrawpay;
 241   GstFlowReturn ret = GST_FLOW_OK;
 242   guint line, offset;
 243   guint8 *p0, *yp, *up, *vp;
 244   guint ystride, uvstride;
 245   guint pgroup;
 246   guint mtu;
 247   guint width, height;
 248   gint field;
 249   GstVideoFrame frame;
 250   gint interlaced;
 251   GstRTPBuffer rtp = { NULL, };
 252
 253   rtpvrawpay = GST_RTP_VRAW_PAY (payload);
 254
 255   gst_video_frame_map (&frame, &rtpvrawpay->vinfo, buffer, GST_MAP_READ);
 256
 257   GST_LOG_OBJECT (rtpvrawpay, "new frame of %" G_GSIZE_FORMAT " bytes",
 258       gst_buffer_get_size (buffer));
 259
 260   /* get pointer and strides of the planes */
 261   p0 = GST_VIDEO_FRAME_PLANE_DATA (&frame, 0);
 262   yp = GST_VIDEO_FRAME_COMP_DATA (&frame, 0);
 263   up = GST_VIDEO_FRAME_COMP_DATA (&frame, 1);
 264   vp = GST_VIDEO_FRAME_COMP_DATA (&frame, 2);
 265
 266   ystride = GST_VIDEO_FRAME_COMP_STRIDE (&frame, 0);
 267   uvstride = GST_VIDEO_FRAME_COMP_STRIDE (&frame, 1);
 268
 269   mtu = GST_RTP_BASE_PAYLOAD_MTU (payload);
 270
 271   /* amount of bytes for one pixel */
 272   pgroup = rtpvrawpay->pgroup;
 273   width = GST_VIDEO_INFO_WIDTH (&rtpvrawpay->vinfo);
 274   height = GST_VIDEO_INFO_HEIGHT (&rtpvrawpay->vinfo);
 275
 276   interlaced = GST_VIDEO_INFO_IS_INTERLACED (&rtpvrawpay->vinfo);
 277
 278   /* start with line 0, offset 0 */
 279   for (field = 0; field < 1 + interlaced; field++) {
 280     line = field;
 281     offset = 0;
 282
 283     /* write all lines */
 284     while (line < height) {
 285       guint left;
 286       GstBuffer *out;
 287       guint8 *outdata, *headers;
 288       gboolean next_line;
 289       guint length, cont, pixels;
 290
 291       /* get the max allowed payload length size, we try to fill the complete MTU */
 292       left = gst_rtp_buffer_calc_payload_len (mtu, 0, 0);
 293       out = gst_rtp_buffer_new_allocate (left, 0, 0);
 294
 295       if (field == 0) {
 296         GST_BUFFER_TIMESTAMP (out) = GST_BUFFER_TIMESTAMP (buffer);
 297       } else {
 298         GST_BUFFER_TIMESTAMP (out) = GST_BUFFER_TIMESTAMP (buffer) +
 299             GST_BUFFER_DURATION (buffer) / 2;
 300       }
 301
 302       gst_rtp_buffer_map (out, GST_MAP_WRITE, &rtp);
 303       outdata = gst_rtp_buffer_get_payload (&rtp);
 304
 305       GST_LOG_OBJECT (rtpvrawpay, "created buffer of size %u for MTU %u", left,
 306           mtu);
 307
 308       /*
 309        *   0                   1                   2                   3
 310        *   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 311        *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 312        *  |   Extended Sequence Number    |            Length             |
 313        *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 314        *  |F|          Line No            |C|           Offset            |
 315        *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 316        *  |            Length             |F|          Line No            |
 317        *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 318        *  |C|           Offset            |                               .
 319        *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               .
 320        *  .                                                               .
 321        *  .                 Two (partial) lines of video data             .
 322        *  .                                                               .
 323        *  +---------------------------------------------------------------+
 324        */
 325
 326       /* need 2 bytes for the extended sequence number */
 327       *outdata++ = 0;
 328       *outdata++ = 0;
 329       left -= 2;
 330
 331       /* the headers start here */
 332       headers = outdata;
 333
 334       /* make sure we can fit at least *one* header and pixel */
 335       if (!(left > (6 + pgroup))) {
 336         gst_rtp_buffer_unmap (&rtp);
 337         gst_buffer_unref (out);
 338         goto too_small;
 339       }
 340
 341       /* while we can fit at least one header and one pixel */
 342       while (left > (6 + pgroup)) {
 343         /* we need a 6 bytes header */
 344         left -= 6;
 345
 346         /* get how may bytes we need for the remaining pixels */
 347         pixels = width - offset;
 348         length = (pixels * pgroup) / rtpvrawpay->xinc;
 349
 350         if (left >= length) {
 351           /* pixels and header fit completely, we will write them and skip to the
 352            * next line. */
 353           next_line = TRUE;
 354         } else {
 355           /* line does not fit completely, see how many pixels fit */
 356           pixels = (left / pgroup) * rtpvrawpay->xinc;
 357           length = (pixels * pgroup) / rtpvrawpay->xinc;
 358           next_line = FALSE;
 359         }
 360         GST_LOG_OBJECT (rtpvrawpay, "filling %u bytes in %u pixels", length,
 361             pixels);
 362         left -= length;
 363
 364         /* write length */
 365         *outdata++ = (length >> 8) & 0xff;
 366         *outdata++ = length & 0xff;
 367
 368         /* write line no */
 369         *outdata++ = ((line >> 8) & 0x7f) | ((field << 7) & 0x80);
 370         *outdata++ = line & 0xff;
 371
 372         if (next_line) {
 373           /* go to next line we do this here to make the check below easier */
 374           line += rtpvrawpay->yinc;
 375         }
 376
 377         /* calculate continuation marker */
 378         cont = (left > (6 + pgroup) && line < height) ? 0x80 : 0x00;
 379
 380         /* write offset and continuation marker */
 381         *outdata++ = ((offset >> 8) & 0x7f) | cont;
 382         *outdata++ = offset & 0xff;
 383
 384         if (next_line) {
 385           /* reset offset */
 386           offset = 0;
 387           GST_LOG_OBJECT (rtpvrawpay, "go to next line %u", line);
 388         } else {
 389           offset += pixels;
 390           GST_LOG_OBJECT (rtpvrawpay, "next offset %u", offset);
 391         }
 392
 393         if (!cont)
 394           break;
 395       }
 396       GST_LOG_OBJECT (rtpvrawpay, "consumed %u bytes",
 397           (guint) (outdata - headers));
 398
 399       /* second pass, read headers and write the data */
 400       while (TRUE) {
 401         guint offs, lin;
 402
 403         /* read length and cont */
 404         length = (headers[0] << 8) | headers[1];
 405         lin = ((headers[2] & 0x7f) << 8) | headers[3];
 406         offs = ((headers[4] & 0x7f) << 8) | headers[5];
 407         cont = headers[4] & 0x80;
 408         pixels = length / pgroup;
 409         headers += 6;
 410
 411         GST_LOG_OBJECT (payload,
 412             "writing length %u, line %u, offset %u, cont %d", length, lin, offs,
 413             cont);
 414
 415         switch (GST_VIDEO_INFO_FORMAT (&rtpvrawpay->vinfo)) {
 416           case GST_VIDEO_FORMAT_RGB:
 417           case GST_VIDEO_FORMAT_RGBA:
 418           case GST_VIDEO_FORMAT_BGR:
 419           case GST_VIDEO_FORMAT_BGRA:
 420           case GST_VIDEO_FORMAT_UYVY:
 421           case GST_VIDEO_FORMAT_UYVP:
 422             offs /= rtpvrawpay->xinc;
 423             memcpy (outdata, p0 + (lin * ystride) + (offs * pgroup), length);
 424             outdata += length;
 425             break;
 426           case GST_VIDEO_FORMAT_AYUV:
 427           {
 428             gint i;
 429             guint8 *datap;
 430
 431             datap = p0 + (lin * ystride) + (offs * 4);
 432
 433             for (i = 0; i < pixels; i++) {
 434               *outdata++ = datap[2];
 435               *outdata++ = datap[1];
 436               *outdata++ = datap[3];
 437               datap += 4;
 438             }
 439             break;
 440           }
 441           case GST_VIDEO_FORMAT_I420:
 442           {
 443             gint i;
 444             guint uvoff;
 445             guint8 *yd1p, *yd2p, *udp, *vdp;
 446
 447             yd1p = yp + (lin * ystride) + (offs);
 448             yd2p = yd1p + ystride;
 449             uvoff =
 450                 (lin / rtpvrawpay->yinc * uvstride) + (offs / rtpvrawpay->xinc);
 451             udp = up + uvoff;
 452             vdp = vp + uvoff;
 453
 454             for (i = 0; i < pixels; i++) {
 455               *outdata++ = *yd1p++;
 456               *outdata++ = *yd1p++;
 457               *outdata++ = *yd2p++;
 458               *outdata++ = *yd2p++;
 459               *outdata++ = *udp++;
 460               *outdata++ = *vdp++;
 461             }
 462             break;
 463           }
 464           case GST_VIDEO_FORMAT_Y41B:
 465           {
 466             gint i;
 467             guint uvoff;
 468             guint8 *ydp, *udp, *vdp;
 469
 470             ydp = yp + (lin * ystride) + offs;
 471             uvoff =
 472                 (lin / rtpvrawpay->yinc * uvstride) + (offs / rtpvrawpay->xinc);
 473             udp = up + uvoff;
 474             vdp = vp + uvoff;
 475
 476             for (i = 0; i < pixels; i++) {
 477               *outdata++ = *udp++;
 478               *outdata++ = *ydp++;
 479               *outdata++ = *ydp++;
 480               *outdata++ = *vdp++;
 481               *outdata++ = *ydp++;
 482               *outdata++ = *ydp++;
 483             }
 484             break;
 485           }
 486           default:
 487             gst_rtp_buffer_unmap (&rtp);
 488             gst_buffer_unref (out);
 489             goto unknown_sampling;
 490         }
 491
 492         if (!cont)
 493           break;
 494       }
 495
 496       if (line >= height) {
 497         GST_LOG_OBJECT (rtpvrawpay, "field/frame complete, set marker");
 498         gst_rtp_buffer_set_marker (&rtp, TRUE);
 499       }
 500       gst_rtp_buffer_unmap (&rtp);
 501       if (left > 0) {
 502         GST_LOG_OBJECT (rtpvrawpay, "we have %u bytes left", left);
 503         gst_buffer_resize (out, 0, gst_buffer_get_size (out) - left);
 504       }
 505
 506       /* push buffer */
 507       ret = gst_rtp_base_payload_push (payload, out);
 508     }
 509
 510   }
 511
 512   gst_video_frame_unmap (&frame);
 513   gst_buffer_unref (buffer);
 514
 515   return ret;
 516
 517   /* ERRORS */
 518 unknown_sampling:
 519   {
 520     GST_ELEMENT_ERROR (payload, STREAM, FORMAT,
 521         (NULL), ("unimplemented sampling"));
 522     gst_video_frame_unmap (&frame);
 523     gst_buffer_unref (buffer);
 524     return GST_FLOW_NOT_SUPPORTED;
 525   }
 526 too_small:
 527   {
 528     GST_ELEMENT_ERROR (payload, RESOURCE, NO_SPACE_LEFT,
 529         (NULL), ("not enough space to send at least one pixel"));
 530     gst_video_frame_unmap (&frame);
 531     gst_buffer_unref (buffer);
 532     return GST_FLOW_NOT_SUPPORTED;
 533   }
 534 }
 535
 536 gboolean
 537 gst_rtp_vraw_pay_plugin_init (GstPlugin * plugin)
 538 {
 539   return gst_element_register (plugin, "rtpvrawpay",
 540       GST_RANK_SECONDARY, GST_TYPE_RTP_VRAW_PAY);
 541 }