video_encoder_base.cpp

完整的RTP RTSP代码库

/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000-2002.  All Rights Reserved.
 * 
 * Contributor(s): 
 *		Dave Mackie		[e-mail]
 */

#include "mp4live.h"
#include "video_encoder.h"
#include "video_encoder_base.h"
#include "mp4av.h"
#include "mp4av_h264.h"

#ifdef HAVE_XVID10
#include "video_xvid10.h"
#else
#ifdef HAVE_XVID_H
#include "video_xvid.h"
#endif
#endif

#ifdef HAVE_FFMPEG
#include "video_ffmpeg.h"
#endif

#ifdef HAVE_X264
#include "video_x264.h"
#endif

#include "h261/encoder-h261.h"
#include "rtp_transmitter.h"

void VideoProfileCheckBase (CVideoProfile *vp)
{
  const char *encoderName = vp->GetStringValue(CFG_VIDEO_ENCODER);
  if (!strcasecmp(encoderName, VIDEO_ENCODER_FFMPEG)) {
#ifdef HAVE_FFMPEG
    return;
#else
    error_message("Profile:%s ffmpeg encoder not available in this build", 
		  vp->GetName());
#if defined(HAVE_XVID10) || defined(HAVE_XVID_H)
    error_message("It has been changed to xvid");
    vp->SetStringValue(CFG_VIDEO_ENCODER, VIDEO_ENCODER_XVID);
    return;
#endif
#endif
  } else if (!strcasecmp(encoderName, VIDEO_ENCODER_XVID)) {

#if defined(HAVE_XVID10) || defined(HAVE_XVID_H)
    return;
#else
    error_message("Profile %s:xvid encoder not available in this build",
		  vp->GetName());
#ifdef HAVE_FFMPEG
    error_message("It has been changed to ffmpeg");
    vp->SetStringValue(CFG_VIDEO_ENCODER, VIDEO_ENCODER_FFMPEG);
    return;
#endif
#endif
  } else if (!strcasecmp(encoderName, VIDEO_ENCODER_X264)) {
#ifdef HAVE_X264
    return;
#else
    error_message("Profile %s:X264 encoder is not available in this build", 
		  vp->GetName());
#endif
  } else if (!strcasecmp(encoderName, VIDEO_ENCODER_H261)) {
    return;
  } else {
    error_message("Profile %s: encoder %s not found", vp->GetName(), encoderName);
  }
  // if we reach here, we want to set the h.261 encoder
  error_message("It has been changed to H.261");
  vp->SetStringValue(CFG_VIDEO_ENCODER, VIDEO_ENCODER_H261);
  vp->SetStringValue(CFG_VIDEO_ENCODING, VIDEO_ENCODING_H261);
  vp->SetIntegerValue(CFG_VIDEO_WIDTH, 352);
  vp->SetIntegerValue(CFG_VIDEO_HEIGHT, 288);
  // called from update, so don't sweat update.
}
  
CVideoEncoder* VideoEncoderCreateBase(CVideoProfile *vp,
				      uint16_t mtu,
				      CVideoEncoder *next, 
				      bool realTime)
{
  const char *encoderName = vp->GetStringValue(CFG_VIDEO_ENCODER);
	if (!strcasecmp(encoderName, VIDEO_ENCODER_FFMPEG)) {
#ifdef HAVE_FFMPEG
		return new CFfmpegVideoEncoder(vp, mtu, next, realTime);
#else
		error_message("ffmpeg encoder not available in this build");
#endif
	} else if (!strcasecmp(encoderName, VIDEO_ENCODER_XVID)) {

#if defined(HAVE_XVID10) || defined(HAVE_XVID_H)

#ifdef HAVE_XVID10
	  return new CXvid10VideoEncoder(vp, mtu, next, realTime);
#else
		return new CXvidVideoEncoder(vp, mtu, next, realTime);
#endif
#else
		error_message("xvid encoder not available in this build");
#endif
	} else if (!strcasecmp(encoderName, VIDEO_ENCODER_X264)) {
#ifdef HAVE_X264
	  return new CX264VideoEncoder(vp, mtu, next, realTime);
#else
	  error_message("X264 encoder is not available in this build");
#endif
	} else if (!strcasecmp(encoderName, VIDEO_ENCODER_H261)) {
	  
	  CH261PixelEncoder *ret;
	  ret = new CH261PixelEncoder(vp, mtu, next, realTime);
	  return ret;

	} else {
		error_message("unknown encoder specified");
	}

	return NULL;
}

void AddVideoProfileEncoderVariablesBase (CVideoProfile *pConfig)
{
#ifdef HAVE_XVID10
  AddXvid10ConfigVariables(pConfig);
#endif
#ifdef HAVE_X264
  AddX264ConfigVariables(pConfig);
#endif
#ifdef HAVE_FFMPEG
  AddFfmpegConfigVariables(pConfig);
#endif
  AddH261ConfigVariables(pConfig);
}
MediaType get_video_mp4_fileinfo_base (CVideoProfile *pConfig,
				       bool *createIod,
				       bool *isma_compliant,
				       uint8_t *videoProfile,
				       uint8_t **videoConfig,
				       uint32_t *videoConfigLen,
				       uint8_t *mp4_video_type)
{
  const char *encodingName = pConfig->GetStringValue(CFG_VIDEO_ENCODING);
  if (!strcasecmp(encodingName, VIDEO_ENCODING_MPEG4)) {
    *createIod = true;
    *isma_compliant = true;
    *videoProfile = pConfig->m_videoMpeg4ProfileId;
    *videoConfig = pConfig->m_videoMpeg4Config;
    *videoConfigLen = pConfig->m_videoMpeg4ConfigLength;

    if (mp4_video_type) {
      *mp4_video_type = MP4_MPEG4_VIDEO_TYPE;
    }
    return MPEG4VIDEOFRAME;
  } else if (!strcasecmp(encodingName, VIDEO_ENCODING_H261)) {
      *createIod = false;
      *isma_compliant = false;
      *videoProfile = 0xff;
      *videoConfig = NULL;
      *videoConfigLen = 0;
    return H261VIDEOFRAME;
  } else if (!strcasecmp(encodingName, VIDEO_ENCODING_MPEG2)) {
    *createIod = false;
    *isma_compliant = false;
    *videoProfile = 0xff;
    *videoConfig = NULL;
    *videoConfigLen = 0;
    if (mp4_video_type) {
      *mp4_video_type = MP4_MPEG2_VIDEO_TYPE;
    }
    return MPEG2VIDEOFRAME;
  } else if (!strcasecmp(encodingName, VIDEO_ENCODING_H263)) {
    *createIod = false;
    *isma_compliant = false;
    *videoProfile = 0xff;
    *videoConfig = NULL;
    *videoConfigLen = 0;
    return H263VIDEOFRAME;
  } else if (!strcasecmp(encodingName, VIDEO_ENCODING_H264)) { 
    *createIod = false;
    *isma_compliant = false;
    *videoProfile = pConfig->m_videoMpeg4ProfileId;
    *videoConfig = pConfig->m_videoMpeg4Config;
    *videoConfigLen = 0;
    return H264VIDEOFRAME;
  }
  return UNDEFINEDFRAME;
}

media_desc_t *create_video_sdp_base(CVideoProfile *pConfig,
				    bool *createIod,
				    bool *isma_compliant,
				    bool *is3gp,
				    uint8_t *videoProfile,
				    uint8_t **videoConfig,
				    uint32_t *videoConfigLen,
				    uint8_t *pPayload_number)
{
  // do the work here for mpeg4 - we know pretty much everything
  media_desc_t *sdpMediaVideo;
  format_list_t *sdpMediaVideoFormat;
  char videoFmtpBuf[512];
  MediaType mtype;
  bool add_to_payload = true;
  uint8_t payload_number = pPayload_number == NULL ? 96 : *pPayload_number;

  mtype = get_video_mp4_fileinfo(pConfig,
				 createIod,
				 isma_compliant,
				 videoProfile,
				 videoConfig,
				 videoConfigLen,
				 NULL);

  sdpMediaVideo = MALLOC_STRUCTURE(media_desc_t);
  memset(sdpMediaVideo, 0, sizeof(*sdpMediaVideo));

  sdpMediaVideoFormat = MALLOC_STRUCTURE(format_list_t);
  memset(sdpMediaVideoFormat, 0, sizeof(*sdpMediaVideoFormat));
  sdpMediaVideo->fmt_list = sdpMediaVideoFormat;

  if (mtype == MPEG4VIDEOFRAME) {
    *is3gp = true;
    sdpMediaVideoFormat->media = sdpMediaVideo;
    sdp_add_string_to_list(&sdpMediaVideo->unparsed_a_lines, 
			   "a=mpeg4-esid:20");
    sdpMediaVideoFormat->fmt = create_payload_number_string(payload_number);
	
    sdpMediaVideoFormat->rtpmap_name = strdup("MP4V-ES");
    sdpMediaVideoFormat->rtpmap_clock_rate = 90000;


    char* sConfig = MP4BinaryToBase16(*videoConfig,
				      *videoConfigLen);

    sprintf(videoFmtpBuf, 
	    "profile-level-id=%u; config=%s;",
	    *videoProfile,
	    sConfig); 
    free(sConfig);

    sdpMediaVideoFormat->fmt_param = strdup(videoFmtpBuf);
  } else if (mtype == H261VIDEOFRAME) {
    sdpMediaVideoFormat->fmt = create_payload_number_string(31);
    add_to_payload = false;
#if 0
    sdpMediaVideoFormat->encode_name = strdup("h261");
    sdpMediaVideoFormat->clock_rate = 90000;
#endif
  } else if (mtype == MPEG2VIDEOFRAME) {
    sdpMediaVideoFormat->fmt = create_payload_number_string(32);
    add_to_payload = false;
  } else if (mtype == H263VIDEOFRAME) {
    *is3gp = true;
    sdpMediaVideoFormat->fmt = create_payload_number_string(payload_number);
    sdpMediaVideoFormat->media = sdpMediaVideo;
    sdpMediaVideoFormat->rtpmap_clock_rate = 90000;
    sdpMediaVideoFormat->rtpmap_name = strdup("H263-2000");
    char cliprect[80];
    sprintf(cliprect, "a=cliprect:0,0,%d,%d",
 	    pConfig->GetIntegerValue(CFG_VIDEO_HEIGHT), 
	    pConfig->GetIntegerValue(CFG_VIDEO_WIDTH));
    sdp_add_string_to_list(&sdpMediaVideo->unparsed_a_lines, cliprect);
  } else if (mtype == H264VIDEOFRAME) {
    sdpMediaVideoFormat->fmt = create_payload_number_string(payload_number);
    sdpMediaVideoFormat->media = sdpMediaVideo;
    sdpMediaVideoFormat->rtpmap_clock_rate = 90000;
    sdpMediaVideoFormat->rtpmap_name = strdup("H264");
    sprintf(videoFmtpBuf, 
	    "profile-level-id=%06x; sprop-parameter-sets=%s; packetization-mode=1",
	    *videoProfile,
	    (char *)*videoConfig);
    sdpMediaVideoFormat->fmt_param = strdup(videoFmtpBuf);
    
  }

  if (add_to_payload && pPayload_number != NULL) {
    *pPayload_number = *pPayload_number + 1;
  }
  return sdpMediaVideo;
}


void create_mp4_video_hint_track_base (CVideoProfile *pConfig,
				       MP4FileHandle mp4file,
				       MP4TrackId trackId,
				       uint16_t mtu)
{
  const char *encodingName = pConfig->GetStringValue(CFG_VIDEO_ENCODING);

  if (!strcasecmp(encodingName, VIDEO_ENCODING_MPEG4)) {
    MP4AV_Rfc3016Hinter(mp4file, 
			trackId,
			mtu);
  } else if (!strcasecmp(encodingName, VIDEO_ENCODING_MPEG2)) {
    Mpeg12Hinter(mp4file, 
		 trackId,
		 mtu);
  } else if (!strcasecmp(encodingName, VIDEO_ENCODING_H263)) {
    MP4AV_Rfc2429Hinter(mp4file, 
			trackId, 
			mtu);
  } else if (!strcasecmp(encodingName, VIDEO_ENCODING_H264)) {
    MP4AV_H264Hinter(mp4file, trackId, mtu);
  }

}

static void H261SendVideo (CMediaFrame *pFrame, CRtpDestination *list,
			   uint32_t rtpTimestamp,
			   uint16_t mtu)
{
  CRtpDestination *rdptr;
  
  pktbuf_t *pData = (pktbuf_t*)pFrame->GetData();
  struct iovec iov[2];
  while (pData != NULL) {
    iov[0].iov_base = &pData->h261_rtp_hdr;
    iov[0].iov_len = sizeof(uint32_t);
    iov[1].iov_base = pData->data;
    iov[1].iov_len = pData->len;
    
    rdptr = list;
    while (rdptr != NULL) {
      //error_message("h.261 - sending %d", pData->len + 4);
      rdptr->send_iov(iov, 2, rtpTimestamp, pData->next == NULL);
      rdptr = rdptr->get_next();
    }
   
    pktbuf_t *n = pData->next;
    pData = n;
  }
  if (pFrame->RemoveReference())
    delete pFrame;
}

static void Mpeg43016SendVideo (CMediaFrame *pFrame, CRtpDestination *list,
				uint32_t rtpTimestamp,
				uint16_t mtu)
{
  CRtpDestination *rdptr;

  u_int8_t* pData;
  u_int32_t bytesToSend = pFrame->GetDataLength();
  struct iovec iov;
  // This will remove any headers other than the VOP header, if a VOP
  // header appears in the stream
  pData = MP4AV_Mpeg4FindVop((uint8_t *)pFrame->GetData(),
			     bytesToSend);
  if (pData) {
    bytesToSend -= (pData - (uint8_t *)pFrame->GetData());
  } else {
    pData = (uint8_t *)pFrame->GetData();
  }

  while (bytesToSend) {
    u_int32_t payloadLength;
    bool lastPacket;

    if (bytesToSend <= mtu) {
      payloadLength = bytesToSend;
      lastPacket = true;
    } else {
      payloadLength = mtu;
      lastPacket = false;
    }

    iov.iov_base = pData;
    iov.iov_len = payloadLength;

    rdptr = list;
    while (rdptr != NULL) {
      int rc = rdptr->send_iov(&iov, 1, rtpTimestamp, lastPacket);
      if (rc != (int)payloadLength) {
	error_message("send_iov error - returned %d %d", rc, payloadLength);
      }
      rdptr = rdptr->get_next();
    }

    pData += payloadLength;
    bytesToSend -= payloadLength;
  }
  if (pFrame->RemoveReference())
    delete pFrame;
}

static void Mpeg2SendVideo (CMediaFrame *pFrame, 
			    CRtpDestination *list,
			    uint32_t rtpTimestamp,