com::avpkit::core::StreamCoder Class Reference

Inheritance diagram for com::avpkit::core::StreamCoder:

Collaboration diagram for com::avpkit::core::StreamCoder:

Public Member Functions
virtual Direction	getDirection ()
	Get the direction. More...
virtual IStream *	getStream ()
	The associated Stream we're working on. More...
virtual Codec *	getCodec ()
	The Codec this StreamCoder will use. More...
virtual ICodec::Type	getCodecType ()
	A short hand for getCodec().getType(). More...
virtual ICodec::ID	getCodecID ()
	A short hand for getCodec().getID(). More...
virtual void	setCodec (ICodec *)
	Set the Codec to the passed in Codec, discarding the old Codec if set. More...
virtual void	setCodec (ICodec::ID)
	Look up a Codec based on the passed in ID, and then set it. More...
virtual void	setCodecID (ICodec::ID id)
	Look up a Codec based on the passed in ID, and then set it. More...
virtual int32_t	getBitRate ()
	The bit rate. More...
virtual void	setBitRate (int32_t rate)
	When ENCODING, sets the bit rate to use. More...
virtual int32_t	getBitRateTolerance ()
	The bit rate tolerance. More...
virtual void	setBitRateTolerance (int32_t tolerance)
	When ENCODING set the bit rate tolerance. More...
virtual int32_t	getHeight ()
	The height, in pixels. More...
virtual void	setHeight (int32_t)
	Set the height, in pixels. More...
virtual int32_t	getWidth ()
	The width, in pixels. More...
virtual void	setWidth (int32_t)
	Set the width, in pixels. More...
virtual IRational *	getTimeBase ()
	Get the time base this stream will ENCODE in, or the time base we detect while DECODING. More...
virtual void	setTimeBase (IRational *newTimeBase)
	Set the time base we'll use to ENCODE with. More...
virtual IRational *	getFrameRate ()
	Get the frame-rate the attached stream claims to be using when DECODING, or the frame-rate we'll claim we're using when ENCODING. More...
virtual void	setFrameRate (IRational *newFrameRate)
	Set the frame rate we'll set in the headers of this stream while ENCODING. More...
virtual int32_t	getNumPicturesInGroupOfPictures ()
	The the number of pictures in this Group of Pictures (GOP). More...
virtual void	setNumPicturesInGroupOfPictures (int32_t gops)
	Set the GOPS on this stream. More...
virtual IPixelFormat::Type	getPixelType ()
	For Video streams, get the Pixel Format in use by the stream. More...
virtual void	setPixelType (IPixelFormat::Type pixelFmt)
	Set the pixel format to ENCODE with. More...
virtual int32_t	getSampleRate ()
	Get the sample rate we use for this stream. More...
virtual void	setSampleRate (int32_t sampleRate)
	Set the sample rate to use when ENCODING. More...
virtual int32_t	getChannels ()
	Get the number of channels in this audio stream. More...
virtual void	setChannels (int32_t channels)
	Set the number of channels to use when ENCODING. More...
virtual IAudioSamples::Format	getSampleFormat ()
	Get the audio sample format. More...
virtual void	setSampleFormat (IAudioSamples::Format aFormat)
	Set the sample format when ENCODING. More...
virtual int32_t	getGlobalQuality ()
	Get the Global Quality setting this codec uses for video if a VideoPicture doesn't have a quality set. More...
virtual void	setGlobalQuality (int32_t newQuality)
	Set the Global Quality to a new value. More...
virtual int32_t	getFlags ()
	Get the flags associated with this codec. More...
virtual void	setFlags (int32_t newFlags)
	Set the FFMPEG flags to use with this codec. More...
virtual bool	getFlag (Flags flag)
	Get the setting for the specified flag. More...
virtual void	setFlag (Flags flag, bool value)
	Set the flag. More...
virtual int32_t	getAudioFrameSize ()
	For this stream, get the number of audio samples that are represented in a packet of information. More...
virtual int32_t	open ()
virtual int32_t	close ()
	Close a Codec that was opened on this StreamCoder. More...
virtual int32_t	decodeAudio (IAudioSamples *pOutSamples, IPacket *packet, int32_t byteOffset)
	Decode this packet into pOutSamples. More...
virtual int32_t	decodeVideo (IVideoPicture *pOutFrame, IPacket *packet, int32_t byteOffset)
	Decode this packet into pOutFrame. More...
virtual int32_t	encodeVideo (IPacket *pOutPacket, IVideoPicture *pFrame, int32_t suggestedBufferSize)
	Encode the given frame using this StreamCoder. More...
virtual int32_t	encodeAudio (IPacket *pOutPacket, IAudioSamples *pSamples, int32_t sampleToStartFrom)
	Encode the given samples using this StreamCoder. More...
virtual int64_t	getNextPredictedPts ()
	For this stream, get the next Pts that we expect to decode. More...
virtual int32_t	getCodecTag ()
	Returns the 4-byte FOURCC tag (Least Significant Byte first). More...
virtual void	setCodecTag (int32_t)
	Set the 4-byte FOURCC tag for this coder. More...
virtual int32_t	getNumProperties ()
	Returns the total number of settable properties on this object. More...
virtual IProperty *	getPropertyMetaData (int32_t propertyNo)
	Returns the name of the numbered property. More...
virtual IProperty *	getPropertyMetaData (const char *name)
	Returns the name of the numbered property. More...
virtual int32_t	setProperty (const char *name, const char *value)
	Sets a property on this Object. More...
virtual int32_t	setProperty (const char *name, double value)
	Looks up the property 'name' and sets the value of the property to 'value'. More...
virtual int32_t	setProperty (const char *name, int64_t value)
	Looks up the property 'name' and sets the value of the property to 'value'. More...
virtual int32_t	setProperty (const char *name, bool value)
	Looks up the property 'name' and sets the value of the property to 'value'. More...
virtual int32_t	setProperty (const char *name, IRational *value)
	Looks up the property 'name' and sets the value of the property to 'value'. More...
virtual char *	getPropertyAsString (const char *name)
	Gets a property on this Object. More...
virtual double	getPropertyAsDouble (const char *name)
	Gets the value of this property, and returns as a double;. More...
virtual int64_t	getPropertyAsLong (const char *name)
	Gets the value of this property, and returns as an long;. More...
virtual IRational *	getPropertyAsRational (const char *name)
	Gets the value of this property, and returns as an IRational;. More...
virtual bool	getPropertyAsBoolean (const char *name)
	Gets the value of this property, and returns as a boolean. More...
virtual bool	isOpen ()
	Returns true if this IStreamCoder is currently open. More...
virtual int32_t	getDefaultAudioFrameSize ()
	Get the default audio frame size (in samples). More...
virtual void	setDefaultAudioFrameSize (int32_t)
	Set the default audio frame size. More...
void	setCodec (int32_t)
int32_t	setStream (Stream *, bool assumeOnlyStream)
int32_t	streamClosed (Stream *)
virtual int64_t	getNumDroppedFrames ()
	Get the number of frames this StreamCoder had to drop to encode at the specified getTimeBase(). More...
virtual void	setAutomaticallyStampPacketsForStream (bool value)
	Should the IStreamCoder automatically adjust time stamps on output packets for the IStream it is ultimately destined for. More...
virtual bool	getAutomaticallyStampPacketsForStream ()
	Does this IStreamCoder automatically adjust time stamps on output packets for the IStream it is ultimately destined for. More...
virtual int32_t	acquire ()
	Internal Only. More...
virtual int32_t	release ()
	Internal Only. More...
virtual int32_t	setExtraData (com::avpkit::ferry::IBuffer *src, int32_t offset, int32_t length, bool allocNew)
	Copies data from the given buffer into the extra-data area maintained by encoders. More...
virtual int32_t	getExtraData (com::avpkit::ferry::IBuffer *dest, int32_t offset, int32_t maxBytesToCopy)
	Copies the current content of the extra-data buffer maintained by this codec (e.g. More...
virtual int32_t	getExtraDataSize ()
	Gets the current number of bytes of data maintained in the coder extra-data area. More...
virtual CodecStandardsCompliance	getStandardsCompliance ()
	Gets the current level of standards compliance. More...
virtual int32_t	setStandardsCompliance (CodecStandardsCompliance compliance)
	Set the level of standards compliance. More...
virtual int32_t	setHardwareDecoding (IPixelFormat::Type type, void *surface=NULL)
	Try to change current decoder to an HW decoder compatible with pixel format. More...
virtual void *	getHardwareSurface ()
virtual int32_t	open (IMetaData *options, IMetaData *unsetOptions)
	Open the codec with the given options. More...
virtual int32_t	setProperty (IMetaData *valuesToSet, IMetaData *valuesNotFound)
Public Member Functions inherited from com::avpkit::ferry::RefCounted
virtual RefCounted *	copyReference ()
	Create a new Java object that refers to the same native object. More...
virtual int32_t	getCurrentRefCount ()
	Return the current reference count on this object. More...
void	setJavaAllocator (void *allocator)
	This method is public but not part of the standard API. More...
void *	getJavaAllocator ()
	This method is public but not part of the standard API. More...

Static Public Member Functions
static StreamCoder *	make (Direction direction)
	This method creates a StreamCoder that is not tied to any container or stream.
static attribute_deprecated StreamCoder *	make (Direction direction, AVCodecContext *context, const AVCodec *, Stream *stream)
	This method creates a StreamCoder that is tied to a specific stream in a container.
static StreamCoder *	make (Direction direction, AVCodecParameters *codecpar, const AVCodec *, Stream *stream)
static StreamCoder *	make (Direction direction, IStreamCoder *copyCoder)
static StreamCoder *	make (Direction direction, Codec *codec)
static StreamCoder *	make (Direction direction, ICodec::ID id)
Static Public Member Functions inherited from com::avpkit::core::IStreamCoder
static IStreamCoder *	make (Direction direction)
static IStreamCoder *	make (Direction direction, IStreamCoder *copyCoder)
	Creates a new IStreamCoder object by copying all the settings in copyCoder. More...
static IStreamCoder *	make (Direction direction, ICodec *codec)
	Create a standalone StreamCoder that can encode or decode data independent of the stream it is attached to. More...
static IStreamCoder *	make (Direction direction, ICodec::ID id)
	Create a standalone StreamCoder that can encode or decode data independent of the stream it is attached to. More...

Additional Inherited Members
Public Types inherited from com::avpkit::core::IStreamCoder
enum	Direction { ENCODING , DECODING }
	The Direction in which this StreamCoder will work.
enum	Flags {   FLAG_QSCALE =0x0002 , FLAG_4MV =0x0004 , FLAG_QPEL =0x0010 , FLAG_GMC =0x0020 ,   FLAG_MV0 =0x0040 , FLAG_INPUT_PRESERVED =0x0100 , FLAG_PASS1 =0x0200 , FLAG_PASS2 =0x0400 ,   FLAG_GRAY =0x2000 , FLAG_EMU_EDGE =0x4000 , FLAG_PSNR =0x8000 , FLAG_TRUNCATED =0x00010000 ,   FLAG_NORMALIZE_AQP =0x00020000 , FLAG_INTERLACED_DCT =0x00040000 , FLAG_LOW_DELAY =0x00080000 , FLAG_GLOBAL_HEADER =0x00400000 ,   FLAG_BITEXACT =0x00800000 , FLAG_AC_PRED =0x01000000 , FLAG_CBP_RD =0x04000000 , FLAG_QP_RD =0x08000000 ,   FLAG_LOOP_FILTER =0x00000800 , FLAG_INTERLACED_ME =0x20000000 , FLAG_CLOSED_GOP =0x80000000 , FLAG2_FAST =0x00000001 ,   FLAG2_STRICT_GOP =0x00000002 , FLAG2_NO_OUTPUT =0x00000004 , FLAG2_LOCAL_HEADER =0x00000008 , FLAG2_SKIP_RD =0x00004000 ,   FLAG2_CHUNKS =0x00008000 , FLAG2_SHOW_ALL =0x00400000 }
	AVPKIT Flags that can be passed to the setFlag(Flags, bool) method. More...
enum	CodecStandardsCompliance {   COMPLIANCE_VERY_STRICT =2 , COMPLIANCE_STRICT =1 , COMPLIANCE_NORMAL =0 , COMPLIANCE_UNOFFICIAL =-1 ,   COMPLIANCE_EXPERIMENTAL =-2 }
	An enumeration of how strictly Codecs may follow the spec. More...
typedef enum com::avpkit::core::IStreamCoder::Direction	Direction
	The Direction in which this StreamCoder will work.
typedef enum com::avpkit::core::IStreamCoder::Flags	Flags
	AVPKIT Flags that can be passed to the setFlag(Flags, bool) method.
Protected Member Functions inherited from com::avpkit::ferry::RefCounted
virtual void	destroy ()
	This method is called by RefCounted objects when their Ref Count reaches zero and they are about to be destroyed.
Protected Attributes inherited from com::avpkit::ferry::RefCounted
AtomicInteger *	mRefCount
	This is the internal reference count, represented as an AtomicInteger to make sure it is thread safe.
void *	mAllocator
	Not part of public API.

Detailed Description

Definition at line 34 of file StreamCoder.h.

Member Function Documentation

acquire()

int32_t com::avpkit::core::StreamCoder::acquire ( )

virtual

Internal Only.

DO NOT USE FROM JAVA.

Acquire a reference to this object. This increments the native internal ref count in native code by +1.

This method is called internally by Ferry in Java, and you should not call it without knowing what you are doing. But if you do call it, make sure you call release() once for each call you make to this method.

Returns

The refcount after the acquire. Note due to multi-threaded issues, you should not rely on this value, as it may change before the method returns to you.

Reimplemented from com::avpkit::ferry::RefCounted.

Definition at line 2067 of file StreamCoder.cpp.

{
  int32_t retval = 0;
  retval = RefCounted::acquire();
  VS_LOG_TRACE("Acquired %p: %d", this, retval);
  return retval;
}

close()

int32_t com::avpkit::core::StreamCoder::close ( )

virtual

Close a Codec that was opened on this StreamCoder.

Returns

>= 0 on success; < 0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 906 of file StreamCoder.cpp.

{
  int32_t retval = -1;
  if (mCodecContext && mOpened)
  {
    retval = avcodec_close(mCodecContext);
    swr_free(&swrContext);
    mOpened = false;
  }
  mBytesInFrameBuffer = 0;
  return retval;
}

decodeAudio()

int32_t com::avpkit::core::StreamCoder::decodeAudio ( IAudioSamples *  pOutSamples, IPacket *  packet, int32_t  byteOffset  )

virtual

Decode this packet into pOutSamples.

It will try to fill up the audio samples object, starting from the byteOffset inside this packet.

The caller is responsible for allocating the IAudioSamples object. This function will overwrite any data in the samples object.

Note that the IAudioSamples object passed in must have a IAudioSamples#getMaxBufferSize() of at least 192kbytes. Sorry, but this requirement is imposed on us via FFmpeg. If the buffer is not large enough, this method will reallocate the underlying buffers to make them at least 192kbytes.

Parameters

pOutSamples	The AudioSamples we decode to
packet	The packet we're attempting to decode from.
byteOffset	Where in the packet payload to start decoding

Returns

number of bytes actually processed from the packet, or negative for error

Implements com::avpkit::core::IStreamCoder.

Definition at line 920 of file StreamCoder.cpp.

{
  int32_t retval = -1;
  AudioSamples *samples = static_cast<AudioSamples*> (pOutSamples);
  Packet* packet = static_cast<Packet*> (pPacket);
 
  if (samples)
    // reset the samples
    samples->setComplete(false, 0, getSampleRate(), getChannels(),
        IAudioSamples::FMT_S16, Global::NO_PTS);
  if (!samples) {
    VS_LOG_WARN("Attempting to decode when not ready; no samples");
    return retval;
  }
//  if (!packet) {
//    VS_LOG_WARN("Attempting to decode when not ready; no packet");
//    return retval;
//  }
  if (!mOpened) {
    VS_LOG_WARN("Attempting to decode when not ready; codec not opened");
    return retval;
  }
  if (!mCodecContext) {
    VS_LOG_WARN("Attempting to decode when not ready; internal context not allocated");
    return retval;
  }
  if (mDirection != DECODING) {
    VS_LOG_WARN("Attempting to decode when not ready; StreamCoder is set to encode, not decode");
    return retval;
  }
  if (!mCodec || !mCodec->canDecode()) {
    VS_LOG_WARN("Attempting to decode when not ready; codec set cannot decode");
    return retval;
  }
  if (getCodecType() != ICodec::CODEC_TYPE_AUDIO) {
    VS_LOG_WARN("Attempting to decode when not ready; codec set is not an audio codec");
    return retval;
  }
 
 
  int outBufSize = 0;
  int32_t inBufSize = 0;
 
  // When decoding with FFMPEG, ffmpeg needs the sample buffer
  // to be at least this long.
  samples->ensureCapacity(192000); //AVCODEC_MAX_AUDIO_FRAME_SIZE
  outBufSize = samples->getMaxBufferSize();
  if (packet)
    inBufSize = packet->getSize() - startingByte;
 
  if (inBufSize > 0 && outBufSize > 0 || mCodec->getAVCodec()->capabilities & AV_CODEC_CAP_DELAY)
  {
    
    uint8_t * inBuf = 0;
    uint8_t * outBuf = 0;
    uint64_t outChannelLayout; 
    AVFrame* frame = av_frame_alloc();
 
    if (packet)
    {
      RefPointer<IBuffer> buffer = packet->getData();
      VS_ASSERT(buffer, "no buffer in packet!");
      if (buffer)
        inBuf = (uint8_t*) buffer->getBytes(startingByte, inBufSize);
      VS_ASSERT(inBuf, "no in buffer");
    }
 
    outBuf = (uint8_t*) samples->getRawSamples(0);
    VS_ASSERT(outBuf, "no out buffer");
    
    if (outBuf)
    {
      VS_LOG_TRACE("Attempting decodeAudio(%p, %p, %d, %p, %d);",
          mCodecContext,
          outBuf,
          outBufSize,
          inBuf,
          inBufSize);
      
      AVPacket pkt;
      av_init_packet(&pkt);
      pkt.data = NULL;
      pkt.size = 0;
 
      if (inBuf) 
      {
        if (packet && packet->getAVPacket())
          pkt = *packet->getAVPacket();
        // copy in our buffer
        pkt.data = inBuf;
        pkt.size = inBufSize;
        mCodecContext->reordered_opaque = packet->getPts();
      }
 
      
      {
        
        int got_frame = 0;
        retval = avcodec_decode_audio4(mCodecContext, frame, &got_frame, &pkt);
//        char ch_layout[64];
//                            av_get_channel_layout_string(ch_layout,
//                                    sizeof (ch_layout),
//                                    0,
//                                    frame->channel_layout);
//        VS_LOG_ERROR("ch layout: %s", ch_layout);
        outChannelLayout = frame->channel_layout;
        // the API for decoding audio changed ot support planar audio and we
        // need to back-port
        
        
        
        if (retval >= 0 && got_frame) {
            if (!swr_is_initialized(swrContext)){
                swr_alloc_set_opts(swrContext,  // we're using an existing context
                      //av_get_default_channel_layout(av_frame_get_channels(frame)),
                      frame->channel_layout == 0 ? av_get_default_channel_layout(frame->channels) : frame->channel_layout, // out_ch_layout
                      AV_SAMPLE_FMT_S16,                // out_sample_fmt
                      frame->sample_rate,       // out_sample_rate
                      //av_frame_get_channel_layout(frame) == 0 ? av_get_default_channel_layout(av_frame_get_channels(frame)) : av_frame_get_channel_layout(frame),    // in_ch_layout
                      frame->channel_layout == 0 ? av_get_default_channel_layout(frame->channels) : frame->channel_layout,    // in_ch_layout
                      mCodecContext->sample_fmt,        // in_sample_fmt
                      frame->sample_rate,       // in_sample_rate
                      0,                                // log_offset
                      NULL);
                swr_init(swrContext);
            }
          
            int outChannels = av_frame_get_channels(frame);
            uint8_t* output[1] = {outBuf};
 
            int out_samples = swr_convert(swrContext, output, frame->nb_samples, (const uint8_t**)frame->extended_data, frame->nb_samples);
            if (out_samples < 0) {
               VS_LOG_ERROR("fail to convert samples: %s", Error::make(out_samples)->getDescription());
               //av_freep(&output);
               return out_samples;
            }
            int data_size = av_samples_get_buffer_size(NULL,
            outChannels,
            out_samples,
            AV_SAMPLE_FMT_S16,
            0);
//            
//         VS_LOG_DEBUG("Finished %d convertAudio(%p, %d, %d, %d, %d, %d);",
//          data_size,
//          plane_size,
//          mCodecContext,
//          out_samples,
//          frame->nb_samples,
//          av_frame_get_channels(frame),
//          outBufSize);
                 
          if (outBufSize < data_size) {
            VS_LOG_ERROR("Output buffer is not large enough; no audio actually returned");
            outBufSize = 0;
          } else {
//            memcpy(outBuf, output, data_size);
            outBufSize = data_size;
//            av_freep(&output);
          }
        }   
 
      }
      VS_LOG_TRACE("Finished %d decodeAudio(%p, %p, %d, %p, %d);",
          retval,
          mCodecContext,
          outBuf,
          outBufSize,
          inBuf,
          inBufSize);
    }
    if (retval >= 0)
    {
      // outBufSize is an In-Out parameter
      if (outBufSize < 0)
        // this can happen for some MPEG decoders
        outBufSize = 0;
 
      IAudioSamples::Format format = IAudioSamples::FMT_S16;
      int32_t bytesPerSample = (IAudioSamples::findSampleBitDepth(format) / 8
          * getChannels());
      int32_t numSamples = outBufSize / bytesPerSample;
 
      // The audio decoder doesn't set a PTS, so we need to manufacture one.
      RefPointer<IRational> timeBase =
          this->mStream ? this->mStream->getTimeBase() : 0;
      if (!timeBase)
        timeBase = this->getTimeBase();
 
      int64_t packetTs = frame->best_effort_timestamp;
//      if (packetTs == Global::NO_PTS)
//        packetTs = packet->getDts();
 
      if (packetTs == Global::NO_PTS && mFakeNextPts == Global::NO_PTS)
      {
        // the container doesn't have time stamps; assume we start
        // at zero
        VS_LOG_TRACE("Setting fake pts to 0");
        mFakeNextPts = 0;
  }
      if (packetTs != Global::NO_PTS)
      {
        // The packet had a valid stream, and a valid time base
        if (timeBase->getNumerator() != 0 && timeBase->getDenominator() != 0)
        {
          int64_t tsDelta = Global::NO_PTS;
          if (mFakeNextPts != Global::NO_PTS)
          {
            int64_t fakeTsInStreamTimeBase = Global::NO_PTS;
            // rescale our fake into the time base of stream
            fakeTsInStreamTimeBase = timeBase->rescale(mFakeNextPts,
                mFakePtsTimeBase.value());
            tsDelta = fakeTsInStreamTimeBase - packetTs;
          }
 
          // now, compare it to our internal value;  if our internally calculated value
          // is within 1 tick of the packet's time stamp (in the packet's time base),
          // then we're probably right;
          // otherwise, we should reset the stream's fake time stamp based on this
          // packet
          if (mFakeNextPts != Global::NO_PTS && (tsDelta >= -1 && tsDelta
              <= 1))
          {
            // we're the right value; keep our fake next pts
            VS_LOG_TRACE("Keeping mFakeNextPts: %lld", mFakeNextPts);
          }
          else
          {
            // rescale to our internal timebase
            int64_t packetTsInMicroseconds = mFakePtsTimeBase->rescale(
                packetTs, timeBase.value());
            VS_LOG_TRACE("%p Gap in audio (%lld); Resetting calculated ts from %lld to %lld",
                this,
                tsDelta,
                mFakeNextPts,
                packetTsInMicroseconds);
            mLastExternallySetTimeStamp = packetTsInMicroseconds;
            mSamplesCoded = 0;
            mFakeNextPts = mLastExternallySetTimeStamp;
          }
        }
      }
      // Use the last value of the next pts
      mFakeCurrPts = mFakeNextPts;
      // adjust our next Pts pointer
      if (numSamples > 0)
      {
        mSamplesCoded += numSamples;
        mFakeNextPts = mLastExternallySetTimeStamp
            + IAudioSamples::samplesToDefaultPts(mSamplesCoded,
                getSampleRate());
      }
 
      // copy the packet PTS
      samples->setComplete(numSamples > 0, numSamples, getSampleRate(),
          getChannels(), (IAudioSamples::ChannelLayout)outChannelLayout, format, mFakeCurrPts);
    }
    
    av_frame_free(&frame);
  }
 
  return retval;
}

References com::avpkit::core::AudioSamples::ensureCapacity(), com::avpkit::core::Packet::getData(), com::avpkit::core::AudioSamples::getMaxBufferSize(), com::avpkit::core::Packet::getPts(), com::avpkit::core::Packet::getSize(), com::avpkit::core::AudioSamples::setComplete(), and com::avpkit::ferry::RefPointer< T >::value().

decodeVideo()

int32_t com::avpkit::core::StreamCoder::decodeVideo ( IVideoPicture *  pOutFrame, IPacket *  packet, int32_t  byteOffset  )

virtual

Decode this packet into pOutFrame.

The caller is responsible for allocating the IVideoPicture object. This function will potentially overwrite any data in the frame object, but you should pass the same IVideoPicture into this function repeatedly until IVideoPicture::isComplete() is true.

Parameters

pOutFrame	The AudioSamples we decode.
packet	The packet we're attempting to decode from.
byteOffset	Where in the packet payload to start decoding

Returns

number of bytes actually processed from the packet, or negative for error

Implements com::avpkit::core::IStreamCoder.

Definition at line 1185 of file StreamCoder.cpp.

{
  int32_t retval = -1;
  VideoPicture* frame = static_cast<VideoPicture*> (pOutFrame);
  Packet* packet = static_cast<Packet*> (pPacket);
  if (frame)
    // reset the frame
    frame->setComplete(false, IPixelFormat::NONE, -1, -1, mFakeCurrPts);
 
  if (!frame) {
    VS_LOG_WARN("Attempting to decode when not ready; no frame");
    return retval;
  }
//  if (!packet) {
//    VS_LOG_WARN("Attempting to decode when not ready; no packet");
//    return retval;
//  }
  if (!mOpened) {
    VS_LOG_WARN("Attempting to decode when not ready; codec not opened");
    return retval;
  }
  if (!mCodecContext) {
    VS_LOG_WARN("Attempting to decode when not ready; internal context not allocated");
    return retval;
  }
  if (mDirection != DECODING) {
    VS_LOG_WARN("Attempting to decode when not ready; StreamCoder is set to encode, not decode");
    return retval;
  }
  if (!mCodec || !mCodec->canDecode()) {
    VS_LOG_WARN("Attempting to decode when not ready; codec set cannot decode");
    return retval;
  }
  if (getCodecType() != ICodec::CODEC_TYPE_VIDEO) {
    VS_LOG_WARN("Attempting to decode when not ready; codec set is not a video codec");
    return retval;
  }
 
  AVFrame *avFrame = av_frame_alloc();
  if (avFrame)
  {
    int frameFinished = 0;
    int32_t inBufSize = 0;
    uint8_t * inBuf = 0;
    if (packet) {
      RefPointer<IBuffer> buffer = packet->getData();
      inBufSize = packet->getSize() - byteOffset;
 
      VS_ASSERT(buffer, "no buffer in packet?");
      if (buffer)
        inBuf = (uint8_t*) buffer->getBytes(byteOffset, inBufSize);
 
      VS_ASSERT(inBuf, "incorrect size or no data in packet");
    }
    
    if (inBufSize > 0 && inBuf || mCodec->getAVCodec()->capabilities & AV_CODEC_CAP_DELAY)
    {
      AVPacket pkt;
      av_init_packet(&pkt);
      pkt.data = NULL;
      pkt.size = 0;
  
      if (inBuf) {
        VS_LOG_TRACE("Attempting decodeVideo(%p, %p, %d, %p, %d);",
            mCodecContext,
            avFrame,
            frameFinished,
            inBuf,
            inBufSize);
        if (packet && packet->getAVPacket())
          pkt = *packet->getAVPacket();
        pkt.data = inBuf;
        pkt.size = inBufSize;
      }
      //mCodecContext->reordered_opaque = packet->getPts();
      retval = avcodec_decode_video2(mCodecContext, avFrame, &frameFinished,
          &pkt);
      VS_LOG_TRACE("Finished %d decodeVideo(%p, %p, %d, %p, %d);",
          retval,
          mCodecContext,
          avFrame,
          frameFinished,
          inBuf,
          inBufSize);
      
      if (retval >= 0) 
      {
 
          if (frameFinished)
          {
            // copy FFMPEG's buffer into our buffer; don't try to get efficient
            // and reuse the buffer FFMPEG is using; in order to allow our
            // buffers to be thread safe, we must do a copy here.
            avFrame->hw_frames_ctx = mCodecContext->hw_frames_ctx;  
            frame->copyAVFrame(avFrame, getPixelType(), getWidth(), getHeight());
            RefPointer<IRational> timeBase = 0;
            timeBase = this->mStream ? this->mStream->getTimeBase() : 0;
            if (!timeBase)
              timeBase = this->getTimeBase();
 
            int64_t packetTs = avFrame->best_effort_timestamp;
 
            if (packetTs != Global::NO_PTS)
            {
              if (timeBase->getNumerator() != 0)
              {
                // The decoder set a PTS, so we let it override us
                int64_t nextPts = mFakePtsTimeBase->rescale(packetTs,
                    timeBase.value());
                // some youtube videos incorrectly return a packet
                // with the wrong re-ordered opaque setting.  this
                // detects that and uses the PTS from the packet instead.
                // See: http://code.google.com/p/avpkit/issues/detail?id=165
                // in this way we enforce that timestamps are always
                // increasing
    //            if (avFrame->reordered_opaque != Global::NO_PTS && nextPts < mFakeNextPts && packet->getPts() != Global::NO_PTS) {
    //              VS_LOG_WARN("Bad order in pts packet pts will be used instead of frame pts (packetTs: %ld, reordered_opaque: %ld, nextPts: %ld, mFakeNextPts: %ld, packet pts: %ld)", 
    //                      packetTs,
    //                      avFrame->reordered_opaque, 
    //                      nextPts,
    //                      mFakeNextPts, 
    //                      packet->getPts());
    //              nextPts = mFakePtsTimeBase->rescale(packet->getPts(),
    //                  timeBase.value());
    //            }
                mFakeNextPts = nextPts;
              }
            }
 
            // Use the last value of the next pts
            mFakeCurrPts = mFakeNextPts;
            double frameDelay = av_rescale(timeBase->getNumerator(),
                AV_TIME_BASE, timeBase->getDenominator());
            frameDelay += avFrame->repeat_pict * (frameDelay * 0.5);
 
            // adjust our next Pts pointer
            mFakeNextPts += (int64_t) frameDelay;
            //          VS_LOG_DEBUG("frame complete: %s; pts: %lld; packet ts: %lld; opaque ts: %lld; tb: %ld/%ld",
            //              (frameFinished ? "yes" : "no"),
            //              mFakeCurrPts,
            //              (packet ? packet->getDts() : 0),
            //              packetTs,
            //              timeBase->getNumerator(),
            //              timeBase->getDenominator()
            //          );
          }
          frame->setComplete(frameFinished, this->getPixelType(),
              this->getWidth(), this->getHeight(), mFakeCurrPts);
 
        }
    }
    av_frame_free(&avFrame);
  }
 
  return retval;
}

References com::avpkit::core::VideoPicture::copyAVFrame(), com::avpkit::core::Packet::getData(), com::avpkit::core::Packet::getSize(), com::avpkit::core::VideoPicture::setComplete(), and com::avpkit::ferry::RefPointer< T >::value().

encodeAudio()

int32_t com::avpkit::core::StreamCoder::encodeAudio ( IPacket *  pOutPacket, IAudioSamples *  pSamples, int32_t  sampleToStartFrom  )

virtual

Encode the given samples using this StreamCoder.

The VideoPicture will allocate a buffer to use internally for this, and will free it when the frame destroys itself.

Callers should call this repeatedly on a set of samples until we consume all the samples.

Also, when done in order to flush the encoder, caller should call this method passing in 0 (null) for pSamples to tell the encoder to flush any data it was keeping a hold of.

Parameters

pOutPacket	[out] The packet to encode into. It will point to a buffer allocated in the frame. Caller should check IPacket::isComplete() after call to find out if we had enough information to encode a full packet.
pSamples	[in] The samples to consume
sampleToStartFrom	[in] Which sample you want to start with This is usually zero, but if you're using a codec that packetizes output with small number of samples, you may need to call encodeAudio repeatedly with different starting samples to consume all of your samples.

Returns

number of samples we consumed when encoding, or negative for errors.

Implements com::avpkit::core::IStreamCoder.

Definition at line 1565 of file StreamCoder.cpp.

{
  int32_t retval = -1;
  AudioSamples *samples = static_cast<AudioSamples*> (pSamples);
  Packet *packet = static_cast<Packet*> (pOutPacket);
  RefPointer<IBuffer> encodingBuffer;
  bool usingInternalFrameBuffer = false;
 
  try
  {
    if (mDirection != ENCODING)
      throw std::runtime_error("Decoding StreamCoder not valid for encoding");
    if (!mCodec)
      throw std::runtime_error("Codec not set");
    if (!mCodec->canEncode()) {
      std::string msg = "Codec cannot be used to encode: ";
      msg += mCodec->getName();
      throw std::runtime_error(msg);
    }
    if (!packet)
      throw std::invalid_argument("Invalid packet to encode to");
    // Zero out our packet
    packet->reset();
 
    if (!mCodecContext)
      throw std::runtime_error("StreamCoder not initialized properly");
    if (!mOpened)
      throw std::runtime_error("StreamCoder not open");
    if (getCodecType() != ICodec::CODEC_TYPE_AUDIO)
      throw std::runtime_error(
          "Attempting to encode audio with non audio coder");
    if (!mAudioFrameBuffer)
      throw std::runtime_error("Audio Frame Buffer not initialized");
 
    // First, how many bytes do we need to encode a packet?
    int32_t frameSize = 0;
    int32_t frameBytes = 0;
    int32_t availableSamples = (samples ? samples->getNumSamples()
        - startingSample : 0);
    int32_t samplesConsumed = 0;
    short *avSamples = (samples ? samples->getRawSamples(startingSample) : 0);
    
    if (samples)
    {
      if (samples->getChannels() != getChannels())
        throw std::invalid_argument(
            "channels in sample do not match StreamCoder");
      if (samples->getSampleRate() != getSampleRate())
        throw std::invalid_argument(
            "sample rate in sample does not match StreamCoder");
 
      if (!samples->isComplete())
        throw std::invalid_argument("input samples are not complete");
 
      if (mFakeNextPts == Global::NO_PTS && samples->getTimeStamp()
          != Global::NO_PTS)
        mFakeNextPts = samples->getTimeStamp()
            + IAudioSamples::samplesToDefaultPts(startingSample,
                getSampleRate());
 
    }
 
    if (mFakeNextPts == Global::NO_PTS)
      mFakeNextPts = 0;
 
    if (availableSamples < 0 || (avSamples && availableSamples == 0))
      throw std::invalid_argument(
          "no bytes in buffer at specified starting sample");
 
    int32_t bytesPerSample = (samples ? samples->getSampleSize()
        : IAudioSamples::findSampleBitDepth(
            (IAudioSamples::FMT_S16)) / 8
            * getChannels());
 
    /*
     * This gets tricky; There may be more audio samples passed to
     * us than can fit in an audio frame, or there may be less.
     *
     * If less, we need to cache for a future call.
     *
     * If more, we need to just use what's needed, and let the caller
     * know the number of samples we used.
     *
     * What happens when we exhaust all audio, but we still don't
     * have enough to decode a frame?  answer: the caller passes us
     * NULL as the pInSamples, and we just silently drop the incomplete
     * frame.
     *
     * To simplify coding here (and hence open for optimization if
     * this ends up being a bottleneck), I always copy audio samples
     * into a frame buffer, and then only encode from the frame buffer
     * in this class.
     */
    frameSize = getAudioFrameSize();
    frameBytes = frameSize * bytesPerSample;
 
    // More error checking
    VS_ASSERT(frameBytes <= mAudioFrameBuffer->getBufferSize(),
        "did frameSize change from open?");
    if (frameBytes > mAudioFrameBuffer->getBufferSize())
      throw std::runtime_error("not enough memory in internal frame buffer");
 
    VS_ASSERT(mBytesInFrameBuffer <= frameBytes,
        "did frameSize change from open?");
    if (frameBytes < mBytesInFrameBuffer)
      throw std::runtime_error(
          "too many bytes left over in internal frame buffer");
    
    uint8_t * frameBuffer = (uint8_t*) mAudioFrameBuffer->getBytes(
        0, frameBytes);
    if (!frameBuffer)
      throw std::runtime_error("could not get internal frame buffer");
 
    int32_t bytesToCopyToFrameBuffer = frameBytes - mBytesInFrameBuffer;
    bytesToCopyToFrameBuffer = FFMIN(bytesToCopyToFrameBuffer,
        availableSamples*bytesPerSample);
 
    uint8_t *convertAvSamples;
            
    if (avSamples)
    {
      if (availableSamples >= frameSize && mBytesInFrameBuffer == 0)
      { //TODO: gerer CODEC_CAP_VARIABLE_FRAME_SIZE CODEC_CAP_SMALL_LAST_FRAME
        VS_LOG_TRACE("audioEncode: Using passed in buffer: %d, %d, %d",
            availableSamples, frameSize, mBytesInFrameBuffer);
        frameBuffer = (uint8_t*)avSamples;
        samplesConsumed = frameSize;
        usingInternalFrameBuffer = false;
      }
      else
      {
        VS_LOG_TRACE("audioEncode: Using internal buffer: %d, %d, %d %d %d",
            availableSamples, frameSize, mBytesInFrameBuffer);
          if (bytesToCopyToFrameBuffer != 0){
              memcpy(frameBuffer + mBytesInFrameBuffer, avSamples, bytesToCopyToFrameBuffer);
              mBytesInFrameBuffer += bytesToCopyToFrameBuffer;
          }
        samplesConsumed = bytesToCopyToFrameBuffer / bytesPerSample;
        retval = samplesConsumed;
        usingInternalFrameBuffer = true;
        
      }
      
      if (mPtsOfFrameBuffer == Global::NO_PTS) {
          RefPointer<IRational> thisTimeBase = getTimeBase();
          mPtsOfFrameBuffer = thisTimeBase->rescale(samples->getTimeStamp() + IAudioSamples::samplesToDefaultPts(startingSample, samples->getSampleRate()), mFakePtsTimeBase.value());
      }
    }
    else
    {
      // drop everything in the frame buffer, and instead
      // just pass a null buffer to the encoder.
 
      // this should happen when the caller passes NULL for the
      // input samples
      frameBuffer = NULL;
    }
    mSamplesForEncoding += samplesConsumed;
    VS_LOG_TRACE("Consumed %ld for total of %lld Need %d got %d",
        samplesConsumed, mSamplesForEncoding, frameBytes, mBytesInFrameBuffer);
 
    if (!frameBuffer || !usingInternalFrameBuffer || mBytesInFrameBuffer
        >= frameBytes)
    {
      // First, get the right buffer size.
      int32_t bufferSize = frameBytes;
      if (mCodecContext->codec->id == AV_CODEC_ID_FLAC
              || mCodecContext->codec->id == AV_CODEC_ID_VORBIS)
      {
        // FLAC & VORBIS audio for some reason gives an error if your output buffer isn't
        // over double the frame size, so we fake it here.  This could be further optimized
        // to only require an exact number, but this math is simpler and will always
        // be large enough.
        bufferSize = (64 + getAudioFrameSize() * (bytesPerSample + 1)) * 2;
      }
      VS_ASSERT(bufferSize> 0, "no buffer size in samples");
      retval = packet->allocateNewPayload(bufferSize);
      if (retval >= 0)
      {
        encodingBuffer = packet->getData();
      }
      
      uint8_t* buf = 0;
 
      if (encodingBuffer)
      {
        buf = (uint8_t*) encodingBuffer->getBytes(0, bufferSize);
      }
      if (buf && bufferSize)
      {
        VS_LOG_TRACE("Attempting encodeAudio(%p, %p, %d, %p)",
            mCodecContext,
            buf,
            bufferSize,
            frameBuffer);
 
        // This hack works around the fact that PCM's codecs
        // calculate samples from buffer length, and sets
        // the wrong frame size, but in
        // reality we're always passing in 2 byte samples.
        // TODO :delete if not necessary
//        double pcmCorrection = 1.0;
//        switch (mCodecContext->codec->id)
//        {
//        case AV_CODEC_ID_PCM_S32LE:
//        case AV_CODEC_ID_PCM_S32BE:
//        case AV_CODEC_ID_PCM_U32LE:
//        case AV_CODEC_ID_PCM_U32BE:
//          pcmCorrection = 2.0;
//          break;
//        case AV_CODEC_ID_PCM_S24LE:
//        case AV_CODEC_ID_PCM_S24BE:
//        case AV_CODEC_ID_PCM_U24LE:
//        case AV_CODEC_ID_PCM_U24BE:
//        case AV_CODEC_ID_PCM_S24DAUD:
//          pcmCorrection = 1.5;
//          break;
//        case AV_CODEC_ID_PCM_S16LE:
//        case AV_CODEC_ID_PCM_S16BE:
//        case AV_CODEC_ID_PCM_U16LE:
//        case AV_CODEC_ID_PCM_U16BE:
//          pcmCorrection = 1.0;
//          break;
//        case AV_CODEC_ID_PCM_ALAW:
//        case AV_CODEC_ID_PCM_MULAW:
//        case AV_CODEC_ID_PCM_S8:
//        case AV_CODEC_ID_PCM_U8:
//        case AV_CODEC_ID_PCM_ZORK:
//          pcmCorrection = 0.5;
//          break;
//        default:
//          pcmCorrection = 1.0;
//        }
               
       int size = 0;
       int got_packet;
       AVPacket pkt;
       av_init_packet(&pkt);
       pkt.data = NULL;
       pkt.size = 0;
 
       if(!pSamples){
           retval = avcodec_encode_audio2(mCodecContext, &pkt, NULL, &got_packet);
       }else{
           int ret = 0;
           if (!swr_is_initialized(swrContext)){
               swr_alloc_set_opts(swrContext, // we're using existing context
                                (int64_t)samples->getChannelLayout(), // out_ch_layout
                                mCodecContext->sample_fmt, // out_sample_fmt
                                samples->getSampleRate(), // out_sample_rate
                                (int64_t)samples->getChannelLayout(), // in_ch_layout
                                AV_SAMPLE_FMT_S16, // in_sample_fmt
                                samples->getSampleRate(), // in_sample_rate
                                0, // log_offset
                                NULL);
               swr_init(swrContext);
           }
           
           
           AVFrame* codingFrame = av_frame_alloc();
           codingFrame->nb_samples     = frameSize;
           codingFrame->format         = mCodecContext->sample_fmt;
           codingFrame->channel_layout = (uint64_t)samples->getChannelLayout();
                      
           if (samples->getPts() != Global::NO_PTS) {
               codingFrame->pts            = mPtsOfFrameBuffer;
           }
           
           
           
           retval = av_frame_get_buffer(codingFrame, 0);
           if (retval<0){
               printf("Error %s",Error::make(retval)->getDescription());
               av_frame_free(&codingFrame);
               throw std::bad_alloc();
           }
 
           ret = swr_convert(swrContext, codingFrame->extended_data, frameSize, (const uint8_t**) &frameBuffer, frameSize);
           if (ret < 0) {
               VS_LOG_ERROR("fail to convert samples: %s", Error::make(ret)->getDescription());
               av_freep(&convertAvSamples);
               throw std::runtime_error("fail to convert samples");
           }
           VS_LOG_TRACE("Finished %d convertAudio(%p, %d, %d, %d, %d, %d);",
                ret,
                swrContext,
                availableSamples > frameSize ? frameSize : availableSamples,
                samples->getNumSamples(),
                frameSize);
        
    retval = avcodec_encode_audio2(mCodecContext, &pkt, codingFrame, &got_packet);
    av_frame_free(&codingFrame);
    }
               
      if (retval>=0 && got_packet){
           packet->wrapAVPacket(&pkt);
           size = packet->getSize();
           av_packet_unref(&pkt);
       }
 
        VS_LOG_TRACE("Finished %d  %d encodeAudio(%d, %p, %d, %d, %p)",
            retval,
            got_packet,
            size,
            mCodecContext,
            samplesConsumed,
            /*buf,*/
            bufferSize,
            frameBuffer);
        // regardless of what happened, nuke any data in our frame
        // buffer.
        mBytesInFrameBuffer = 0;
        mPtsOfFrameBuffer = Global::NO_PTS;
        if (retval >= 0)
        {
          // and only do this if a packet is returned
          if (retval >= 0 && got_packet)
          {
           
            mSamplesCoded += frameSize;
 
            // let's check to see if the time stamp of passed in
            // samples (if any) are within tolerance of our expected
            // time stamp.  if not, this is most likely happening
            // because the IStreamCoder's data source lost a packet.
            // We will adjust our starting time stamps then for this new
            // packet
            mFakeCurrPts = mFakeNextPts;
            if (samples && samples->getTimeStamp() != Global::NO_PTS)
            {
            int64_t samplesTs = samples->getTimeStamp()
                  + IAudioSamples::samplesToDefaultPts(startingSample
                      + samplesConsumed, getSampleRate());
              int64_t samplesCached = mSamplesForEncoding - mSamplesCoded;
              int64_t tsDelta = IAudioSamples::samplesToDefaultPts(
                  samplesCached, getSampleRate());
              int64_t gap = samplesTs - (mFakeNextPts + tsDelta);
 
              // ignore negative gaps; some containers like WMV
              // don't actually set the right time stamps, and we
              // can assume a negative gap can't happen
              if ((gap > 1))
              {
                VS_LOG_TRACE("reset;"
                    "samplesTs:%lld;"
                    "samplesConsumed:%ld;"
                    "startingSample:%lu;"
                    "samplesForEncoding:%lld;"
                    "samplesCoded:%lld;"
                    "samplesCached:%lld;"
                    "tsDelta:%lld;"
                    "fakeNextPts:%lld;"
                    "gap:%lld;"
                    "lastExternallySetTs:%lld;"
                    "new fakeNextPts:%lld;",
                    samplesTs,
                    samplesConsumed,
                    startingSample,
                    mSamplesForEncoding,
                    mSamplesCoded,
                    samplesCached,
                    tsDelta,
                    mFakeNextPts,
                    gap,
                    mLastExternallySetTimeStamp,
                    samplesTs - tsDelta);
                mLastExternallySetTimeStamp = samplesTs - tsDelta;
                mSamplesCoded = 0;
                mSamplesForEncoding = samplesCached;
              }
            }
            mFakeNextPts = mLastExternallySetTimeStamp
                + IAudioSamples::samplesToDefaultPts(mSamplesCoded,
                    getSampleRate());
 
          }
          RefPointer<IRational> thisTimeBase = getTimeBase();
          int64_t ts;
          int64_t duration = IAudioSamples::samplesToDefaultPts(frameSize,
              getSampleRate());
          if (!thisTimeBase)
          {
            thisTimeBase.reset(mFakePtsTimeBase.value(), true);
            ts = mFakeCurrPts;
          }
          else
          {
            ts = thisTimeBase->rescale(mFakeCurrPts, mFakePtsTimeBase.value());
            duration
                = thisTimeBase->rescale(duration, mFakePtsTimeBase.value());
          }
          setPacketParameters(packet, size, ts, thisTimeBase.value(), true,
              duration, got_packet);
          //printf("%d\n",(int)ts);
          //          setPacketParameters(packet, size, packet->getAVPacket()->dts, thisTimeBase.value(), true,
//              packet->getAVPacket()->duration);
 
          retval = samplesConsumed;
        }
        else
        {
          throw std::runtime_error("avcodec_encode_audio failed");
        }
      }
    }
  }
  catch (std::bad_alloc & e)
  {
    throw e;
  }
  catch (std::exception& e)
  {
    VS_LOG_WARN("error: %s", e.what());
    retval = -1;
  }
 
  return retval;
}

References com::avpkit::core::Packet::allocateNewPayload(), com::avpkit::core::AudioSamples::getChannels(), com::avpkit::core::Packet::getData(), com::avpkit::core::AudioSamples::getNumSamples(), com::avpkit::core::AudioSamples::getPts(), com::avpkit::core::AudioSamples::getSampleRate(), com::avpkit::core::AudioSamples::getSampleSize(), com::avpkit::core::Packet::getSize(), com::avpkit::core::AudioSamples::getTimeStamp(), com::avpkit::core::AudioSamples::isComplete(), com::avpkit::core::Packet::reset(), com::avpkit::ferry::RefPointer< T >::reset(), and com::avpkit::ferry::RefPointer< T >::value().

encodeVideo()

int32_t com::avpkit::core::StreamCoder::encodeVideo ( IPacket *  pOutPacket, IVideoPicture *  pFrame, int32_t  suggestedBufferSize  )

virtual

Encode the given frame using this StreamCoder.

The VideoPicture will allocate a buffer to use internally for this, and will free it when the frame destroys itself.

Also, when done in order to flush the encoder, caller should call this method passing in 0 (null) for pFrame to tell the encoder to flush any data it was keeping a hold of.

Parameters

pOutPacket	[out] The packet to encode into. It will point to a buffer allocated in the frame. Caller should check IPacket::isComplete() after call to find out if we had enough information to encode a full packet.
pFrame	[in/out] The frame to encode
suggestedBufferSize	The suggested buffer size to allocate or -1 for choose ourselves. If -1 we'll allocate a buffer exactly the same size (+1) as the decoded frame with the guess that you're encoding a frame because you want to use LESS space than that.

@ return >= 0 on success; <0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 1344 of file StreamCoder.cpp.

{
  int32_t retval = -1;
  VideoPicture *frame = static_cast<VideoPicture*> (pFrame);
  Packet *packet = static_cast<Packet*> (pOutPacket);
  RefPointer<IBuffer> encodingBuffer;
 
  try
  {
    if (packet)
      packet->reset();
 
    if (getCodecType() != ICodec::CODEC_TYPE_VIDEO)
      throw std::runtime_error(
          "Attempting to encode video with non video coder");
 
    if (frame && frame->getPixelType() != this->getPixelType())
      throw std::runtime_error(
          "picture is not of the same PixelType as this Coder expected");
    if (frame && frame->getWidth() != this->getWidth())
      throw std::runtime_error("picture is not of the same width as this Coder");
    if (frame && frame->getHeight() != this->getHeight())
      throw std::runtime_error(
          "picture is not of the same height as this Coder");
 
    if (mDirection != ENCODING)
      throw std::runtime_error("Decoding StreamCoder not valid for encoding");
    if (!mCodec)
      throw std::runtime_error("Codec not set");
    if (!mCodec->canEncode())
      throw std::runtime_error("Codec cannot be used to encode");
    if (mCodecContext && mOpened && mDirection == ENCODING && packet)
    {
      uint8_t* buf = 0;
      int32_t bufLen = 0;
 
      // First, get the right buffer size.
      if (suggestedBufferSize <= 0)
      {
        if (frame)
        {
          suggestedBufferSize = frame->getSize();
        }
        else
        {
          suggestedBufferSize = av_image_get_buffer_size(
              (AVPixelFormat) getPixelType(), getWidth(), getHeight(), 1);
        }
      }
      VS_ASSERT(suggestedBufferSize> 0, "no buffer size in input frame");
      suggestedBufferSize = FFMAX(suggestedBufferSize, AV_INPUT_BUFFER_MIN_SIZE);
 
      retval = packet->allocateNewPayload(suggestedBufferSize);
      if (retval >= 0)
      {
        encodingBuffer = packet->getData();
      }
      if (encodingBuffer)
      {
        buf = (uint8_t*) encodingBuffer->getBytes(0, suggestedBufferSize);
        bufLen = encodingBuffer->getBufferSize();
      }
 
      if (buf && bufLen || mCodec->getAVCodec()->capabilities & AV_CODEC_CAP_DELAY)
      {
        // Change the PTS in our frame to the timebase of the encoded stream
        RefPointer<IRational> thisTimeBase = getTimeBase();
 
        /*
         * We make a copy of the AVFrame object and explicitly copy
         * over the values that we know encoding cares about.
         *
         * This is because often some programs decode into an VideoPicture
         * and just want to pass that to encodeVideo.  If we just
         * leave the values that Ffmpeg had in the AVFrame during
         * decoding, strange errors can result.
         *
         * Plus, this forces us to KNOW what we're passing into the encoder.
         */
        AVFrame* avFrame = 0;
        bool dropFrame = false;
        if (frame)
        {
          avFrame = av_frame_alloc();
          if (!avFrame)
            throw std::bad_alloc();
          frame->fillAVFrame(avFrame);
 
          // convert into the time base that this coder wants
          // to output in
          int64_t codecTimeBasePts = thisTimeBase->rescale(frame->getPts(),
              mFakePtsTimeBase.value(), IRational::ROUND_DOWN);
          if (mLastPtsEncoded != Global::NO_PTS)
          {
            // adjust for rounding;
            // fixes http://code.google.com/p/avpkit/issues/detail?id=180
            if (codecTimeBasePts < mLastPtsEncoded)
            {
              VS_LOG_TRACE(
                  "Dropping frame with timestamp %lld (if coder supports higher time-base use that instead)",
                  frame->getPts());
              dropFrame = true;
            }
            else if (codecTimeBasePts == mLastPtsEncoded)
            {
              // else we're close enough; increment by 1
              ++codecTimeBasePts;
            }
          }
          VS_LOG_TRACE("Rescaling ts: %lld to %lld (last: %lld) (from base %d/%d to %d/%d)",
              frame->getPts(),
              codecTimeBasePts,
              mLastPtsEncoded,
              mFakePtsTimeBase->getNumerator(),
              mFakePtsTimeBase->getDenominator(),
              thisTimeBase->getNumerator(),
              thisTimeBase->getDenominator());
          avFrame->pts = codecTimeBasePts;
          if (!dropFrame)
            mLastPtsEncoded = avFrame->pts;
        }
 
        int got_pkt;
          
        if (!dropFrame)
        {
          VS_LOG_TRACE("Attempting encodeVideo(%p, %p, %d, %p)",
              mCodecContext,
              buf,
              bufLen,
              avFrame);
          packet->getAVPacket()->size = suggestedBufferSize;
          retval = avcodec_encode_video2(mCodecContext, packet->getAVPacket(), avFrame, &got_pkt);
//          retval = avcodec_encode_video(mCodecContext, buf, bufLen, avFrame);
 
        }
        else
        {
          ++mNumDroppedFrames;
          retval = 0;
        }
        if (retval == 0)
        {
          int64_t dts = (avFrame ? mLastPtsEncoded : mLastPtsEncoded + 1);
          int64_t duration = 1;
          if (got_pkt) {
            int32_t num = thisTimeBase->getNumerator();
            int32_t den = thisTimeBase->getDenominator();
            if (num*1000LL > den)
            {
              if (mCodecContext->coded_frame
                  && mCodecContext->coded_frame->repeat_pict)
              {
                num = num * (1+mCodecContext->coded_frame->repeat_pict);
              }
            }
            duration = av_rescale(1,
                num * (int64_t)den * mCodecContext->ticks_per_frame,
                den * (int64_t) thisTimeBase->getNumerator());
 
            // This will be zero if the Codec does not use b-frames;
            // although we provide space for delaying up to the
            // max H264 delay, in reality we only need delay by 1 tick.
            int32_t delay = FFMAX(mCodecContext->has_b_frames,
                mCodecContext->max_b_frames > 0);
            dts = packet->getAVPacket()->dts;
            if (packet->getAVPacket()->pts != Global::NO_PTS && dts == Global::NO_PTS && delay <= MAX_REORDER_DELAY)
            {
              int64_t pts = packet->getAVPacket()->pts;
              mPtsBuffer[0] = pts;
              int32_t i;
              // If first time through set others to some 'sensible' defaults.
              // If the first PTS is zero, this leads to starting negative
              // dts values, but FFmpeg allows that so we do too.
              for(i = 1; i < delay + 1 && mPtsBuffer[i] == Global::NO_PTS; i++)
                mPtsBuffer[i] = pts + (i-delay-1)*duration;
              // Order the PTS values in increasing order and the lowest
              // one will magically be the DTS we should use for this packet.
              for(i = 0; i < delay && mPtsBuffer[i] > mPtsBuffer[i+1]; i++)
                FFSWAP(int64_t, mPtsBuffer[i], mPtsBuffer[i+1]);
              dts = mPtsBuffer[0];
//              VS_LOG_ERROR("type: %d; output: dts: %lld; pts: %lld",
//                  mCodecContext->coded_frame->pict_type,
//                  dts,
//                  pts);
            }
          }
          setPacketParameters(
              packet,
              got_pkt ? packet->getAVPacket()->size : retval,
              // if the last packet, increment the pts encoded
              // by one
              dts,
              thisTimeBase.value(),
              (packet->getAVPacket()->flags & AV_PKT_FLAG_KEY), duration, got_pkt);
        }
        if (avFrame)
          av_free(avFrame);
      }
    }
    else
    {
      VS_LOG_WARN("Attempting to encode when not ready");
    }
  }
  catch (std::bad_alloc & e)
  {
    retval = -1;
    throw e;
  }
  catch (std::exception & e)
  {
    VS_LOG_WARN("Got error: %s", e.what());
    retval = -1;
  }
 
  return retval;
}

References com::avpkit::core::Packet::allocateNewPayload(), com::avpkit::core::VideoPicture::fillAVFrame(), com::avpkit::core::Packet::getData(), com::avpkit::core::VideoPicture::getHeight(), com::avpkit::core::VideoPicture::getPixelType(), com::avpkit::core::VideoPicture::getPts(), com::avpkit::core::VideoPicture::getSize(), com::avpkit::core::VideoPicture::getWidth(), com::avpkit::core::Packet::reset(), and com::avpkit::ferry::RefPointer< T >::value().

getAudioFrameSize()

int32_t com::avpkit::core::StreamCoder::getAudioFrameSize ( )

virtual

For this stream, get the number of audio samples that are represented in a packet of information.

Returns

Number of samples per 'frame' of encoded audio

Implements com::avpkit::core::IStreamCoder.

Definition at line 2035 of file StreamCoder.cpp.

{
  int32_t retval = 0;
  if (mCodec && mCodec->getType() == ICodec::CODEC_TYPE_AUDIO)
  {
    if (mCodecContext->frame_size <= 1)
    {
      // Rats; some PCM encoders give a frame size of 1, which is too
      //small.  We pick a more sensible value.
      retval = getDefaultAudioFrameSize();
    }
    else
    {
      retval = mCodecContext->frame_size;
    }
  }
  return retval;
}

getAutomaticallyStampPacketsForStream()

bool com::avpkit::core::StreamCoder::getAutomaticallyStampPacketsForStream ( )

virtual

Does this IStreamCoder automatically adjust time stamps on output packets for the IStream it is ultimately destined for.

Returns

true for yes; false for no

See also

setAutomaticallyStampPacketsForStream(bool)

Since

3.2

Implements com::avpkit::core::IStreamCoder.

Definition at line 2240 of file StreamCoder.cpp.

{
  return mAutomaticallyStampPacketsForStream;
}

getBitRate()

int32_t com::avpkit::core::StreamCoder::getBitRate ( )

virtual

The bit rate.

Returns

The bit-rate the stream is, or will be, encoded in.

Implements com::avpkit::core::IStreamCoder.

Definition at line 511 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->bit_rate : -1);
}

getBitRateTolerance()

int32_t com::avpkit::core::StreamCoder::getBitRateTolerance ( )

virtual

The bit rate tolerance.

Returns

The bit-rate tolerance

Implements com::avpkit::core::IStreamCoder.

Definition at line 522 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->bit_rate_tolerance : -1);
}

getChannels()

int32_t com::avpkit::core::StreamCoder::getChannels ( )

virtual

Get the number of channels in this audio stream.

Returns

The sample rate (in Hz) we use for this stream, or 0 if unknown.

Implements com::avpkit::core::IStreamCoder.

Definition at line 690 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->channels : -1);
}

getCodec()

Codec * com::avpkit::core::StreamCoder::getCodec ( )

virtual

The Codec this StreamCoder will use.

Returns

The Codec used by this StreamCoder, or 0 (null) if none.

Implements com::avpkit::core::IStreamCoder.

Definition at line 475 of file StreamCoder.cpp.

{
  return mCodec ? mCodec.get() : 0;
}

Referenced by com::avpkit::core::Container::addNewStream().

getCodecID()

ICodec::ID com::avpkit::core::StreamCoder::getCodecID ( )

virtual

A short hand for getCodec().getID().

Note for Native (C++) users:

If you actually write code like the above from Native code, you'd leak a Codec() since you didn't call release() on it. This method is a short hand way to avoid you having to worry about releasing in between.

Returns

The ID of the Codec we'll use.

Implements com::avpkit::core::IStreamCoder.

Definition at line 496 of file StreamCoder.cpp.

{
  ICodec::ID retval = ICodec::AV_CODEC_ID_NONE;
  if (mCodecContext)
  {
    retval = (ICodec::ID) mCodecContext->codec_id;
  }
  else
  {
    VS_LOG_WARN("Attempt to get CodecID from uninitialized StreamCoder");
  }
  return retval;
}

getCodecTag()

int32_t com::avpkit::core::StreamCoder::getCodecTag ( )

virtual

Returns the 4-byte FOURCC tag (Least Significant Byte first).

This is really a packed 4-byte array so it's only useful if you use bit-wise operations on it. Some language wrappings may provide more obvious ways of manipulating, but this is the safest way to do this that will work with all wrappers.

Returns

the FOURCC tag.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2085 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->codec_tag : 0);
}

getCodecType()

ICodec::Type com::avpkit::core::StreamCoder::getCodecType ( )

virtual

A short hand for getCodec().getType().

Note for Native (C++) users:

If you actually write code like the above from Native code, you'd leak a Codec() since you didn't call release() on it. This method is a short hand way to avoid you having to worry about releasing in between.

Returns

The Type of the Codec we'll use.

Implements com::avpkit::core::IStreamCoder.

Definition at line 481 of file StreamCoder.cpp.

{
  ICodec::Type retval = ICodec::CODEC_TYPE_UNKNOWN;
  if (mCodecContext)
  {
    retval = (ICodec::Type) mCodecContext->codec_type;
  }
  else
  {
    VS_LOG_WARN("Attempt to get CodecType from uninitialized StreamCoder");
  }
  return retval;
}

getDefaultAudioFrameSize()

int32_t com::avpkit::core::StreamCoder::getDefaultAudioFrameSize ( )

virtual

Get the default audio frame size (in samples).

Some codecs, especially raw codecs, like PCM, don't have a standard frame size. In those cases, we use the value of this setting to determine how many samples to encode into a single packet.

Returns

the number of samples in an audio frame size if the codec doesn't specify the size.

Since

1.21

Implements com::avpkit::core::IStreamCoder.

Definition at line 2189 of file StreamCoder.cpp.

{
  return mDefaultAudioFrameSize;
}

getDirection()

virtual Direction com::avpkit::core::StreamCoder::getDirection ( )

inlinevirtual

Get the direction.

Returns

The direction this StreamCoder works in.

Implements com::avpkit::core::IStreamCoder.

Definition at line 43 of file StreamCoder.h.

{ return mDirection; }

getExtraData()

int32_t com::avpkit::core::StreamCoder::getExtraData ( com::avpkit::ferry::IBuffer *  dest, int32_t  offset, int32_t  maxBytesToCopy  )

virtual

Copies the current content of the extra-data buffer maintained by this codec (e.g.

header bytes) into the dest buffer.

Parameters

dest	The buffer to copy to.
offset	The position, in bytes, to start writing data to in dest.
maxBytesToCopy	The maximum number of bytes to copy.

Returns

The number of bytes copied, or < 0 on error.

Since

3.3

Implements com::avpkit::core::IStreamCoder.

Definition at line 2281 of file StreamCoder.cpp.

{
  if (!mCodecContext || !mCodecContext->extradata
      || mCodecContext->extradata_size <= 0 || !dest || offset < 0
      || maxBytesToCopy < 0 || dest->getSize() < offset + maxBytesToCopy)
    return 0;
 
  int32_t bytesToCopy = FFMIN(maxBytesToCopy, mCodecContext->extradata_size);
  if (bytesToCopy <= 0)
    return 0;
  void* bytes = dest->getBytes(offset, bytesToCopy);
  if (!bytes)
    return 0;
  memcpy(bytes, mCodecContext->extradata, bytesToCopy);
  return bytesToCopy;
}

References com::avpkit::ferry::IBuffer::getBytes().

getExtraDataSize()

int32_t com::avpkit::core::StreamCoder::getExtraDataSize ( )

virtual

Gets the current number of bytes of data maintained in the coder extra-data area.

Returns

The number of bytes. If 0, then no data is currently available.

Since

3.3

Implements com::avpkit::core::IStreamCoder.

Definition at line 2300 of file StreamCoder.cpp.

{
  if (mCodecContext)
    return mCodecContext->extradata_size;
  return 0;
}

getFlag()

bool com::avpkit::core::StreamCoder::getFlag ( Flags  flag )

virtual

Get the setting for the specified flag.

Parameters

flag	The flag you want to find the setting for

Returns

0 for false; non-zero for true

Implements com::avpkit::core::IStreamCoder.

Definition at line 731 of file StreamCoder.cpp.

{
  bool result = false;
  if (mCodecContext)
    result = mCodecContext->flags & flag;
  return result;
}

getFlags()

int32_t com::avpkit::core::StreamCoder::getFlags ( )

virtual

Get the flags associated with this codec.

Returns

The (compacted) value of all flags set.

Implements com::avpkit::core::IStreamCoder.

Definition at line 718 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->flags : 0);
}

getFrameRate()

IRational * com::avpkit::core::StreamCoder::getFrameRate ( )

virtual

Get the frame-rate the attached stream claims to be using when DECODING, or the frame-rate we'll claim we're using when ENCODING.

Returns

The frame rate.

Implements com::avpkit::core::IStreamCoder.

Definition at line 601 of file StreamCoder.cpp.

{
  if (mCodecContext && mCodecContext->framerate.num > 0) {
      return Rational::make(&mCodecContext->framerate);
  }  
  return (mStream ? mStream->getFrameRate() : 0);
}

getGlobalQuality()

int32_t com::avpkit::core::StreamCoder::getGlobalQuality ( )

virtual

Get the Global Quality setting this codec uses for video if a VideoPicture doesn't have a quality set.

Returns

The global quality.

Implements com::avpkit::core::IStreamCoder.

Definition at line 703 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->global_quality : FF_LAMBDA_MAX);
}

getHeight()

int32_t com::avpkit::core::StreamCoder::getHeight ( )

virtual

The height, in pixels.

Returns

The height of the video frames in the attached stream or -1 if an audio stream, or we cannot determine the height.

Implements com::avpkit::core::IStreamCoder.

Definition at line 533 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->height : -1);
}

getNextPredictedPts()

int64_t com::avpkit::core::StreamCoder::getNextPredictedPts ( )

virtual

For this stream, get the next Pts that we expect to decode.

Note that this may not actually be the next Pts (for example due to transmission packet drops in the input source). Still it can be a useful tool.

Returns

The next presentation time stamp we expect to decode on this stream. This is always in units of 1/1,000,000 seconds

Implements com::avpkit::core::IStreamCoder.

Definition at line 595 of file StreamCoder.cpp.

{
  return mFakeNextPts;
}

getNumDroppedFrames()

int64_t com::avpkit::core::StreamCoder::getNumDroppedFrames ( )

virtual

Get the number of frames this StreamCoder had to drop to encode at the specified getTimeBase().

IStreamCoder objects can encode audio and video, but guarantee that every packet outputted has monotonically increasing timestamps (i.e. 0, 1, 2, 3, 4, 5, etc. without repeats). Sometimes data is passed too quickly into an IStreamCoder via encodeVideo or encodeAudio, and the underlying codec can't handle it that quickly. In those cases the IStreamCoder must drop the most recent frame of data.

If you're seeing a lot of dropped frames you can try either sending less frequent data to the IStreamCoder, or adjusting the getTimeBase() to the highest possible resolution. Be warned though; some codecs (such as MPEG2) require fixed time-bases (like 1/25) and so setting a higher resolution time base might end up with the codec not able to encode any data.

Returns

the number of frames dropped.

Since

3.1

Implements com::avpkit::core::IStreamCoder.

Definition at line 2227 of file StreamCoder.cpp.

{
  return mNumDroppedFrames;
}

getNumPicturesInGroupOfPictures()

int32_t com::avpkit::core::StreamCoder::getNumPicturesInGroupOfPictures ( )

virtual

The the number of pictures in this Group of Pictures (GOP).

See the MPEG specs for what a GOP is officially, but this is the minimum number of frames between key-frames (or Intra-Frames in MPEG speak).

Returns

the GOPS for this stream.

Implements com::avpkit::core::IStreamCoder.

Definition at line 622 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->gop_size : -1);
}

getNumProperties()

int32_t com::avpkit::core::StreamCoder::getNumProperties ( )

virtual

Returns the total number of settable properties on this object.

Returns

total number of options (not including constant definitions)

Implements com::avpkit::core::IStreamCoder.

Definition at line 2098 of file StreamCoder.cpp.

{
  return Property::getNumProperties(mCodecContext);
}

getPixelType()

IPixelFormat::Type com::avpkit::core::StreamCoder::getPixelType ( )

virtual

For Video streams, get the Pixel Format in use by the stream.

Returns

the Pixel format, or IPixelFormat::NONE if audio.

Implements com::avpkit::core::IStreamCoder.

Definition at line 635 of file StreamCoder.cpp.

{
  IPixelFormat::Type retval = IPixelFormat::NONE;
  int32_t type = 0;
  if (mCodecContext)
  {
    retval = (IPixelFormat::Type) mCodecContext->pix_fmt;
 
    // little check here to see if we have an undefined int32_t.
    type = (int32_t) retval;
    if (type != mCodecContext->pix_fmt) {
      VS_LOG_ERROR("Undefined pixel format type: %d", mCodecContext->pix_fmt);
      retval = IPixelFormat::NONE;
    }
  }
  return retval;
}

getPropertyAsBoolean()

bool com::avpkit::core::StreamCoder::getPropertyAsBoolean ( const char *  name )

virtual

Gets the value of this property, and returns as a boolean.

Parameters

name	name of option

Returns

boolean value of property, or false on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2177 of file StreamCoder.cpp.

{
  return Property::getPropertyAsBoolean(mCodecContext, aName);
}

getPropertyAsDouble()

double com::avpkit::core::StreamCoder::getPropertyAsDouble ( const char *  name )

virtual

Gets the value of this property, and returns as a double;.

Parameters

name	name of option

Returns

double value of property, or 0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2159 of file StreamCoder.cpp.

{
  return Property::getPropertyAsDouble(mCodecContext, aName);
}

getPropertyAsLong()

int64_t com::avpkit::core::StreamCoder::getPropertyAsLong ( const char *  name )

virtual

Gets the value of this property, and returns as an long;.

Parameters

name	name of option

Returns

long value of property, or 0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2165 of file StreamCoder.cpp.

{
  return Property::getPropertyAsLong(mCodecContext, aName);
}

getPropertyAsRational()

IRational * com::avpkit::core::StreamCoder::getPropertyAsRational ( const char *  name )

virtual

Gets the value of this property, and returns as an IRational;.

Parameters

name	name of option

Returns

long value of property, or 0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2171 of file StreamCoder.cpp.

{
  return Property::getPropertyAsRational(mCodecContext, aName);
}

getPropertyAsString()

char * com::avpkit::core::StreamCoder::getPropertyAsString ( const char *  name )

virtual

Gets a property on this Object.

Note for C++ callers; you must free the returned array with delete[] in order to avoid a memory leak. Other language folks need not worry.

Parameters

name	property name

Returns

an string copy of the option value, or null if the option doesn't exist.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2153 of file StreamCoder.cpp.

{
  return Property::getPropertyAsString(mCodecContext, aName);
}

getPropertyMetaData() [1/2]

IProperty * com::avpkit::core::StreamCoder::getPropertyMetaData ( const char *  name )

virtual

Returns the name of the numbered property.

Parameters

name	The property name.

Returns

an IProperty value for this properties meta-data

Implements com::avpkit::core::IStreamCoder.

Definition at line 2110 of file StreamCoder.cpp.

{
  return Property::getPropertyMetaData(mCodecContext, name);
}

getPropertyMetaData() [2/2]

IProperty * com::avpkit::core::StreamCoder::getPropertyMetaData ( int32_t  propertyNo )

virtual

Returns the name of the numbered property.

Parameters

propertyNo

The property number in the options list.

Returns

an IProperty value for this properties meta-data

Implements com::avpkit::core::IStreamCoder.

Definition at line 2104 of file StreamCoder.cpp.

{
  return Property::getPropertyMetaData(mCodecContext, propertyNo);
}

getSampleFormat()

IAudioSamples::Format com::avpkit::core::StreamCoder::getSampleFormat ( )

virtual

Get the audio sample format.

Returns

The sample format of samples for encoding/decoding.

Implements com::avpkit::core::IStreamCoder.

Definition at line 676 of file StreamCoder.cpp.

{
  return (IAudioSamples::Format) (mCodecContext ? mCodecContext->sample_fmt
      : -1);
}

getSampleRate()

int32_t com::avpkit::core::StreamCoder::getSampleRate ( )

virtual

Get the sample rate we use for this stream.

Returns

The sample rate (in Hz) we use for this stream, or -1 if unknown or video.

Implements com::avpkit::core::IStreamCoder.

Definition at line 663 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->sample_rate : -1);
}

getStandardsCompliance()

IStreamCoder::CodecStandardsCompliance com::avpkit::core::StreamCoder::getStandardsCompliance ( )

virtual

Gets the current level of standards compliance.

Returns

The level of standards compliance.

See also

CodecStandardsCompliance

Since

5.0

Implements com::avpkit::core::IStreamCoder.

Definition at line 2308 of file StreamCoder.cpp.

{
  if (mCodecContext)
    return (CodecStandardsCompliance) mCodecContext->strict_std_compliance;
  return (CodecStandardsCompliance)0;
}

getStream()

IStream * com::avpkit::core::StreamCoder::getStream ( )

virtual

The associated Stream we're working on.

Returns

The stream associated with this object.

Implements com::avpkit::core::IStreamCoder.

Definition at line 467 of file StreamCoder.cpp.

{
  // Acquire for the caller.
  VS_REF_ACQUIRE(mStream);
  return mStream;
}

getTimeBase()

IRational * com::avpkit::core::StreamCoder::getTimeBase ( )

virtual

Get the time base this stream will ENCODE in, or the time base we detect while DECODING.

Caller must call release() on the returned value.

Returns

The time base this StreamCoder is using.

Implements com::avpkit::core::IStreamCoder.

Definition at line 559 of file StreamCoder.cpp.

{
  // we make a new value and return it; caller must
  // release.
  IRational *retval = 0;
 
  // annoyingly, some codec contexts will NOT have
  // a timebase... so we take it from stream then.
  if (mCodecContext && mCodecContext->time_base.den
      && mCodecContext->time_base.num)
  {
    retval = Rational::make(&mCodecContext->time_base);
  }
  else if (mAutomaticallyStampPacketsForStream)
  {
    retval = mStream ? mStream->getTimeBase() : 0;
  }
 
  return retval;
}

getWidth()

int32_t com::avpkit::core::StreamCoder::getWidth ( )

virtual

The width, in pixels.

Returns

The width of the video frames in the attached stream or -1 if an audio stream, or we cannot determine the width.

Implements com::avpkit::core::IStreamCoder.

Definition at line 546 of file StreamCoder.cpp.

{
  return (mCodecContext ? mCodecContext->width : -1);
}

isOpen()

bool com::avpkit::core::StreamCoder::isOpen ( )

virtual

Returns true if this IStreamCoder is currently open.

Returns

true if open; false if not

Implements com::avpkit::core::IStreamCoder.

Definition at line 2183 of file StreamCoder.cpp.

{
  return mOpened;
}

Referenced by com::avpkit::core::Stream::setStreamCoder().

open() [1/2]

int32_t com::avpkit::core::StreamCoder::open ( )

virtual

Deprecated:

Use open(IMetaData,IMetaData) instead.

Open the Codec associated with this StreamCoder.

You can get the codec through getCodec(...) and set it with setCodec(...). You cannot call any set* methods after you've called open() on this StreamCoder until you close() it.

You must call close() when you're done, but if you don't, the container will clean up after you (but yell at you) when it is closed.

Returns

>= 0 on success; < 0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 757 of file StreamCoder.cpp.

{
  return open(NULL, NULL);
}

open() [2/2]

int32_t com::avpkit::core::StreamCoder::open ( IMetaData *  options, IMetaData *  unsetOptions  )

virtual

Open the codec with the given options.

Callers must call setCodec before calling this method.

Parameters

options	If non-NULL, a dictionary of parameter options to set for this codec.
unsetOptions	If non-NULL, on successful return the prior contents of this set of meta data will be replaced with any settings in 'options' that could not be set on this codec.

Returns

0 on success; <0 on error

Since

5.0

Implements com::avpkit::core::IStreamCoder.

Definition at line 762 of file StreamCoder.cpp.

{
  int32_t retval = -1;
  AVDictionary* tmp= NULL;
  try
  {
    if (!swrContext)
      swrContext = swr_alloc();      
    if (!mCodecContext)
      throw std::runtime_error("no codec context");
 
    if (!mCodec)
    {
      RefPointer<ICodec> codec = this->getCodec();
      // This should set mCodec and then release
      // the local reference.
    }
 
    if (!mCodec)
      throw std::runtime_error("no codec set for coder");
 
    // Time to set options
    if (aOptions) {
        MetaData* options = static_cast<MetaData*>(aOptions);
        if (!options)
          throw new std::runtime_error("wow... who's passing us crap?");
 
        // make a copy of the data returned.
        av_dict_copy(&tmp, options->getDictionary(), 0);
    }
 
    // don't allow us to open a coder without a time base
    if (mDirection == ENCODING && mCodecContext->time_base.num == 0)
    {
      if (this->getCodecType() == ICodec::CODEC_TYPE_AUDIO)
      {
        if (mCodecContext->sample_rate > 0)
        {
          mCodecContext->time_base.num = 1;
          mCodecContext->time_base.den = mCodecContext->sample_rate;
        }
        else
        {
          throw std::runtime_error("no sample rate set on coder");
        }
      }
    }
 
    if (mDirection == ENCODING && this->getCodecType() == ICodec::CODEC_TYPE_AUDIO && !mCodecContext->channel_layout)
    {
      mCodecContext->channel_layout = av_get_default_channel_layout(mCodecContext->channels);
    }
 
    // Fix for issue #14: http://code.google.com/p/avpkit/issues/detail?id=14
    if (mStream)
    {
      RefPointer<IContainer> container = mStream->getContainer();
      if (container)
      {
        RefPointer<IContainerFormat> format = container->getContainerFormat();
        if (format && mDirection == ENCODING && format->getOutputFlag(
            IContainerFormat::FLAG_GLOBALHEADER))
        {
          this->setFlag(FLAG_GLOBAL_HEADER, true);
        }
      }
    }
 
    {
      /*
       * This is a very annoying bug.  FFmpeg will NOT find sub-codec options
       * if AVCodecContext->codec is not set to a non-null value, but
       * avcodec_open2 will fail if it is set null.  To allow users to set
       * options easily prior to opening the AVCodecContext, we stash the
       * value we had been using, and we check after the open call and log
       * an error if it changed for some reason.
       */
      //const AVCodec* cachedCodec = mCodecContext->codec;
      //mCodecContext->codec = NULL;
      retval = avcodec_open2(mCodecContext, mCodec->getAVCodec(), &tmp);
 
//      if (retval >= 0 && cachedCodec != 0 && cachedCodec != mCodecContext->codec)
//      {
//        VS_LOG_ERROR("When opening StreamCoder the codec was changed by FFmpeg.  This is not good");
//      }
      if (retval < 0)
      {
        //mCodecContext->codec = cachedCodec;
        throw std::runtime_error("could not open codec");
      }
    }
    
    if (mDirection == ENCODING && mStream) {
        avcodec_parameters_from_context(mStream->getAVStream()->codecpar, mCodecContext);
    }
    
    mOpened = true;
 
    mNumDroppedFrames = 0;
    mSamplesCoded = mSamplesForEncoding = mLastExternallySetTimeStamp = 0;
    mFakeCurrPts = mFakeNextPts = mLastPtsEncoded = Global::NO_PTS;
    for(uint32_t i = 0; i < sizeof(mPtsBuffer)/sizeof(mPtsBuffer[0]); i++)
    {
      mPtsBuffer[i] = Global::NO_PTS;
    }
 
    // Do any post open initialization here.
    if (this->getCodecType() == ICodec::CODEC_TYPE_AUDIO)
    {
      int32_t frame_bytes = getAudioFrameSize() * getChannels()
          * IAudioSamples::findSampleBitDepth(
              (IAudioSamples::Format) mCodecContext->sample_fmt) / 8;
      if (frame_bytes <= 0)
        frame_bytes = 192000; //AVCODEC_MAX_AUDIO_FRAME_SIZE disappear
 
      if (!mAudioFrameBuffer || mAudioFrameBuffer->getBufferSize()
          < frame_bytes)
        // Re-create it.
        mAudioFrameBuffer = IBuffer::make(this, frame_bytes);
      mBytesInFrameBuffer = 0;
    }
    if (aUnsetOptions)
    {
      MetaData* unsetOptions = static_cast<MetaData*>(aUnsetOptions);
      if (!unsetOptions)
        throw std::runtime_error("really... seriously?");
      unsetOptions->copy(tmp);
    }
  }
  catch (std::bad_alloc & e)
  {
    throw e;
  }
  catch (std::exception & e)
  {
    VS_LOG_WARN("Error: %s", e.what());
    retval = -1;
  }
  if (tmp)
    av_dict_free(&tmp);
  return retval;
}

References com::avpkit::core::MetaData::copy(), and com::avpkit::core::MetaData::getDictionary().

release()

int32_t com::avpkit::core::StreamCoder::release ( )

virtual

Internal Only.

DO NOT USE FROM JAVA.

This decrements the native internal ref count by -1; the object is destroyed if its ref count reaches zero.

This method is called internally by Ferry in Java, and you should not call it without knowing what you are doing. But if you do call it, make sure you had previously called acquire() once for each call to release() you make.

Returns

The ref count after the release. Note due to multi-threaded issues, you should not rely on this value, as it may change before the method returns to you.

Reimplemented from com::avpkit::ferry::RefCounted.

Definition at line 2076 of file StreamCoder.cpp.

{
  int32_t retval = 0;
  retval = RefCounted::release();
  VS_LOG_TRACE("Released %p: %d", this, retval);
  return retval;
}

setAutomaticallyStampPacketsForStream()

void com::avpkit::core::StreamCoder::setAutomaticallyStampPacketsForStream ( bool  value )

virtual

Should the IStreamCoder automatically adjust time stamps on output packets for the IStream it is ultimately destined for.

If this IStreamCoder does not know which IStream it is destined for, or this IStreamCoder isn't used with an IStream at all, then this setting is ignored.

Parameters

value

true to automatically adjust.

Since

3.2

Implements com::avpkit::core::IStreamCoder.

Definition at line 2233 of file StreamCoder.cpp.

{
  //  VS_LOG_DEBUG("setAutomaticallyStampPacketsForStream: %d", value);
  mAutomaticallyStampPacketsForStream = value;
}

setBitRate()

void com::avpkit::core::StreamCoder::setBitRate ( int32_t  rate )

virtual

When ENCODING, sets the bit rate to use.

No-op when DECODING.

See also

getBitRate()

Parameters

rate	The bit rate to use.

Implements com::avpkit::core::IStreamCoder.

Definition at line 516 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened)
    mCodecContext->bit_rate = val;
}

setBitRateTolerance()

void com::avpkit::core::StreamCoder::setBitRateTolerance ( int32_t  tolerance )

virtual

When ENCODING set the bit rate tolerance.

No-op when DECODING.

Parameters

tolerance

The bit rate tolerance

Implements com::avpkit::core::IStreamCoder.

Definition at line 527 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened)
    mCodecContext->bit_rate_tolerance = val;
}

setChannels()

void com::avpkit::core::StreamCoder::setChannels ( int32_t  channels )

virtual

Set the number of channels to use when ENCODING.

Ignored if a non audio stream, or if DECODING.

Parameters

channels

The number of channels we'll encode with.

Implements com::avpkit::core::IStreamCoder.

Definition at line 696 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened && val > 0)
    mCodecContext->channels = val;
}

setCodec() [1/2]

void com::avpkit::core::StreamCoder::setCodec ( ICodec *  codec )

virtual

Set the Codec to the passed in Codec, discarding the old Codec if set.

Once you call setCodec, all settings on the IStreamCoder are reset to default values. So you probably want to call this first.

Parameters

codec

Codec to set.

Implements com::avpkit::core::IStreamCoder.

Definition at line 207 of file StreamCoder.cpp.

{
  Codec* codec = static_cast<Codec*>(aCodec);
  const AVCodec* avCodec = NULL;
 
  if (!codec) {
    VS_LOG_INFO("Cannot set codec to null codec");
    return;
  }
  avCodec = codec->getAVCodec();
 
  if (!mCodecContext) {
    VS_LOG_ERROR("No codec context");
    return;
  }
 
  if (mCodecContext->codec_id != AV_CODEC_ID_NONE || mCodecContext->codec) {
    VS_LOG_INFO("Codec already set to codec: %d. Ignoring setCodec call",
        mCodecContext->codec_id);
    return;
  }
 
  if (mCodec.value() == aCodec) {
    // setting to the same value; don't reset anything
    return;
  }
 
  if (mCodecContext) {
    // avcodec_get_context_defaults3 does not clear these out if already allocated
    // so we do.
    resetOptions(mCodecContext);
    av_freep(&mCodecContext->extradata);
    av_freep(&mCodecContext->subtitle_header);
    avcodec_free_context(&mCodecContext);
  }
 
    mCodecContext = avcodec_alloc_context3(avCodec);
 
  if (mCodecContext)
    readyAVContexts(mDirection,
        this,
        mStream,
        codec,
        mCodecContext,
        NULL);
}

Referenced by setCodecID().

setCodec() [2/2]

void com::avpkit::core::StreamCoder::setCodec ( ICodec::ID  id )

virtual

Look up a Codec based on the passed in ID, and then set it.

To see if you actually set the correct ID, call getCodec() and check for 0 (null).

Once you call setCodec, all settings on the IStreamCoder are reset to default values. So you probably want to call this first.

Parameters

id	ID of codec to set.

Implements com::avpkit::core::IStreamCoder.

Definition at line 255 of file StreamCoder.cpp.

{
  setCodec((int32_t) id);
}

setCodecID()

virtual void com::avpkit::core::StreamCoder::setCodecID ( ICodec::ID  id )

inlinevirtual

Look up a Codec based on the passed in ID, and then set it.

Forwards to setCodecID(com.avpkit.core.ICodec.ID)

To see if you actually set the correct ID, call getCodec() and check for 0 (null).

Once you call setCodec, all settings on the IStreamCoder are reset to default values. So you probably want to call this first.

Parameters

id	ID of codec to set.

Since

3.2

Implements com::avpkit::core::IStreamCoder.

Definition at line 53 of file StreamCoder.h.

{ setCodec(id); }

References setCodec().

setCodecTag()

void com::avpkit::core::StreamCoder::setCodecTag ( int32_t  fourcc )

virtual

Set the 4-byte FOURCC tag for this coder.

Parameters

fourcc

The FOURCC to set, with Least Significant Byte first.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2091 of file StreamCoder.cpp.

{
  if (mCodecContext)
    mCodecContext->codec_tag = tag;
}

setDefaultAudioFrameSize()

void com::avpkit::core::StreamCoder::setDefaultAudioFrameSize ( int32_t  aNewSize )

virtual

Set the default audio frame size.

Parameters

aNewSize

The new number of samples to use to encode samples into a packet. This setting is ignored if <= 0 or if the codec requires it's own frame size (e.g. Nellymoser).

See also

getDefaultAudioFrameSize()

Since

1.21

Implements com::avpkit::core::IStreamCoder.

Definition at line 2195 of file StreamCoder.cpp.

{
  if (aNewSize > 0)
    mDefaultAudioFrameSize = aNewSize;
}

setExtraData()

int32_t com::avpkit::core::StreamCoder::setExtraData ( com::avpkit::ferry::IBuffer *  src, int32_t  offset, int32_t  length, bool  allocNew  )

virtual

Copies data from the given buffer into the extra-data area maintained by encoders.

This is an extremely advanced method, and incorrect usage can result in Java crashes so take care. In general people should not need to use this.

For some codecs (e.g. for H264, this is global header information and for rv10 it is additional flags), AVPKit maintains extra information about the codec in a extra data buffer. In general AVPKit will allocate this data as needed and you never need to set it (or get it). But if you know what you're doing, you can ask AVPKit to replace the existing extra data for the given codec with a copy of the data in the given buffer.

You should call this method after you call open() but before you encode or decode any media.

Parameters

src	The data to copy
offset	The position, in bytes, to start copying data from src
length	The number of bytes to copy from data
allocNew	If true, and there is not enough space in the existing extra data buffer, then AVPKit will discard the old buffer and allocate a new buffer. If false, then AVPKit will attempt to copy the data into the existing buffer and if there is not enough space in the existing buffer, no bytes will be copied and an error will be returned. In general, you should set this to false if that works for you.

Returns

The number of bytes copied, or < 0 on error.

Since

3.3

Implements com::avpkit::core::IStreamCoder.

Definition at line 2246 of file StreamCoder.cpp.

{
  if (!mCodecContext || !src)
    return -1;
 
  void* bytes = src->getBytes(offset, numBytes);
  if (!bytes)
    return -1;
 
  if (mCodecContext->extradata_size < numBytes || !mCodecContext->extradata)
  {
    if (allocNew)
    {
      av_free(mCodecContext->extradata);
      mCodecContext->extradata_size = 0;
      mCodecContext->extradata = (uint8_t*) av_malloc(numBytes
          + AV_INPUT_BUFFER_MIN_SIZE);
      if (!mCodecContext->extradata)
      {
        return -1;
      }
      mCodecContext->extradata_size = numBytes;
    }
    else
      return -1;
  }
  memcpy(mCodecContext->extradata, bytes, numBytes);
  
  if (mStream) {
    avcodec_parameters_from_context(mStream->getAVStream()->codecpar, mCodecContext);
  }
  return numBytes;
}

References com::avpkit::ferry::IBuffer::getBytes().

setFlag()

void com::avpkit::core::StreamCoder::setFlag ( Flags  flag, bool  value  )

virtual

Set the flag.

Parameters

flag	The flag to set
value	The value to set it to (true or false)

Implements com::avpkit::core::IStreamCoder.

Definition at line 740 of file StreamCoder.cpp.

{
  if (mCodecContext)
  {
    if (value)
    {
      mCodecContext->flags |= flag;
    }
    else
    {
      mCodecContext->flags &= (~flag);
    }
  }
 
}

setFlags()

void com::avpkit::core::StreamCoder::setFlags ( int32_t  newFlags )

virtual

Set the FFMPEG flags to use with this codec.

All values must be ORed (|) together.

See also

Flags

Parameters

newFlags

The new set flags for this codec.

Implements com::avpkit::core::IStreamCoder.

Definition at line 724 of file StreamCoder.cpp.

{
  if (mCodecContext)
    mCodecContext->flags = newFlags;
}

setFrameRate()

void com::avpkit::core::StreamCoder::setFrameRate ( IRational *  newFrameRate )

virtual

Set the frame rate we'll set in the headers of this stream while ENCODING.

Note that you can set whatever frame-rate you'd like, but the TimeBase and the PTS you set on the encoded audio and video frames can override this.

As a convenience, we forward this call to the Stream::setFrameRate() method.

See also

getFrameRate()

Parameters

newFrameRate

The new frame rate to use.

Implements com::avpkit::core::IStreamCoder.

Definition at line 610 of file StreamCoder.cpp.

{
  if (mStream && !mOpened)
    mStream->setFrameRate(src);
  if (mCodecContext && !mOpened && src){
      mCodecContext->framerate.den = src->getDenominator();
      mCodecContext->framerate.num = src->getNumerator();
  }
  
}

References com::avpkit::core::IRational::getDenominator(), and com::avpkit::core::IRational::getNumerator().

setGlobalQuality()

void com::avpkit::core::StreamCoder::setGlobalQuality ( int32_t  newQuality )

virtual

Set the Global Quality to a new value.

Parameters

newQuality

The new global quality.

Implements com::avpkit::core::IStreamCoder.

Definition at line 709 of file StreamCoder.cpp.

{
  if (newQuality < 0 || newQuality > FF_LAMBDA_MAX)
    newQuality = FF_LAMBDA_MAX;
  if (mCodecContext)
    mCodecContext->global_quality = newQuality;
}

setHardwareDecoding()

int32_t com::avpkit::core::StreamCoder::setHardwareDecoding ( IPixelFormat::Type  type, void *  surface = NULL  )

virtual

Try to change current decoder to an HW decoder compatible with pixel format.

Parameters

type	an HW accelerated pixel format

Returns

0 on success; non-zero on failure

Implements com::avpkit::core::IStreamCoder.

Definition at line 2325 of file StreamCoder.cpp.

{
  if (!(av_pix_fmt_desc_get((AVPixelFormat)type)->flags & AV_PIX_FMT_FLAG_HWACCEL)) {
      VS_LOG_WARN("Requested type is not hardware accelerated, default decoder will be used instead %d %d", av_pix_fmt_desc_get((AVPixelFormat)type)->flags, AV_PIX_FMT_FLAG_HWACCEL);
      return 0;
  } 
  
  if (mCodecContext && mStream) {
    AVBufferRef* device_ctx = NULL;  
    Codec* codec = Codec::findDecodingCodec(mCodec->getID(), type);
    if (!codec) {
        VS_LOG_WARN("No hardware decoder found for requested type, looking for hwaccel");
        for (int i = 0;; i++) {
            const AVCodecHWConfig *config = avcodec_get_hw_config(mCodec->getAVCodec(), i);
            if (!config) {
                VS_LOG_WARN("Decoder %s does not support any device type",
                        mCodec->getAVCodec()->name);
                break;
            }
            if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
                config->pix_fmt == (AVPixelFormat)type) {
                if (av_hwdevice_ctx_create(&device_ctx, config->device_type, NULL, NULL, 0) < 0) {
                    VS_LOG_WARN("Unable to create device for type %s", av_hwdevice_get_type_name(config->device_type));
                    return -1;
                }
                mCodecContext->hw_device_ctx = av_buffer_ref(device_ctx);
                return 0;
            }
        }
        if (!device_ctx) {
            VS_LOG_WARN("No hardware decoder found for requested type, default decoder will be used instead");
            return 0;
        }      
    }
    
    avcodec_free_context(&mCodecContext);
    mCodecContext = avcodec_alloc_context3(codec->getAVCodec());
    if (mCodecContext){
        if (avcodec_parameters_to_context(mCodecContext, mStream->getAVStream()->codecpar) < 0)
            throw std::runtime_error("could not initialize codec");
    }
    
    readyAVContexts(mDirection,
        this,
        mStream,
        codec,
        mCodecContext,
        NULL); 
    
    if (type == IPixelFormat::MEDIACODEC) { 
      #ifdef __ANDROID__
      if (!mCodecContext->hwaccel_context && surface){  
        jobject jSurface = static_cast<jobject>(surface);
        if (jSurface){
          mediacodec_alloc_context(mCodecContext, JNIHelper::sGetEnv(), jSurface);
        }
      }
      #elif __APPLE__
      #else
      VS_LOG_WARN("Try to use MediaCodec Android hardware type on non Android platform");
      #endif
    } else {
      VS_LOG_WARN("Hardware context not yet supported %s", mCodecContext->hwaccel->name);
    }
  } else {
    VS_LOG_WARN("try to set HW decoding on uninitialized AVContext or AVStream");
  }   
  return 0;
}

setHeight()

void com::avpkit::core::StreamCoder::setHeight ( int32_t  height )

virtual

Set the height, in pixels.

See also

getHeight()

Parameters

height

Sets the height of video frames we'll encode. No-op when DECODING.

Implements com::avpkit::core::IStreamCoder.

Definition at line 539 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened)
    mCodecContext->height = val;
}

setNumPicturesInGroupOfPictures()

void com::avpkit::core::StreamCoder::setNumPicturesInGroupOfPictures ( int32_t  gops )

virtual

Set the GOPS on this stream.

Ignored if DECODING.

See also

getNumPicturesInGroupOfPictures()

Parameters

gops	The new GOPS for the stream we're encoding.

Implements com::avpkit::core::IStreamCoder.

Definition at line 628 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened)
    mCodecContext->gop_size = val;
}

setPixelType()

void com::avpkit::core::StreamCoder::setPixelType ( IPixelFormat::Type  pixelFmt )

virtual

Set the pixel format to ENCODE with.

Ignored if audio or DECODING.

Parameters

pixelFmt

Pixel format to use.

Implements com::avpkit::core::IStreamCoder.

Definition at line 654 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened)
  {
    mCodecContext->pix_fmt = (AVPixelFormat) type;
  }
}

setProperty() [1/5]

int32_t com::avpkit::core::StreamCoder::setProperty ( const char *  name, bool  value  )

virtual

Looks up the property 'name' and sets the value of the property to 'value'.

Parameters

name	name of option
value	Value of option

Returns

>= 0 on success; <0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2141 of file StreamCoder.cpp.

{
  return Property::setProperty(mCodecContext, aName, aValue);
}

setProperty() [2/5]

int32_t com::avpkit::core::StreamCoder::setProperty ( const char *  name, const char *  value  )

virtual

Sets a property on this Object.

All AVOptions supported by the underlying AVClass are supported.

Parameters

name	The property name. For example "b" for bit-rate.
value	The value of the property.

Returns

>= 0 if the property was successfully set; <0 on error

Implements com::avpkit::core::IStreamCoder.

Definition at line 2123 of file StreamCoder.cpp.

{
  return Property::setProperty(mCodecContext, aName, aValue);
}

setProperty() [3/5]

int32_t com::avpkit::core::StreamCoder::setProperty ( const char *  name, double  value  )

virtual

Looks up the property 'name' and sets the value of the property to 'value'.

Parameters

name	name of option
value	Value of option

Returns

>= 0 on success; <0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2129 of file StreamCoder.cpp.

{
  return Property::setProperty(mCodecContext, aName, aValue);
}

setProperty() [4/5]

int32_t com::avpkit::core::StreamCoder::setProperty ( const char *  name, int64_t  value  )

virtual

Looks up the property 'name' and sets the value of the property to 'value'.

Parameters

name	name of option
value	Value of option

Returns

>= 0 on success; <0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2135 of file StreamCoder.cpp.

{
  return Property::setProperty(mCodecContext, aName, aValue);
}

setProperty() [5/5]

int32_t com::avpkit::core::StreamCoder::setProperty ( const char *  name, IRational *  value  )

virtual

Looks up the property 'name' and sets the value of the property to 'value'.

Parameters

name	name of option
value	Value of option

Returns

>= 0 on success; <0 on error.

Implements com::avpkit::core::IStreamCoder.

Definition at line 2147 of file StreamCoder.cpp.

{
  return Property::setProperty(mCodecContext, aName, aValue);
}

setSampleFormat()

void com::avpkit::core::StreamCoder::setSampleFormat ( IAudioSamples::Format  aFormat )

virtual

Set the sample format when ENCODING.

Ignored if DECODING or if the coder is already open.

Parameters

aFormat

The sample format.

Implements com::avpkit::core::IStreamCoder.

Definition at line 683 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened && val > 0)
    mCodecContext->sample_fmt = (enum AVSampleFormat) val;
}

setSampleRate()

void com::avpkit::core::StreamCoder::setSampleRate ( int32_t  sampleRate )

virtual

Set the sample rate to use when ENCODING.

Ignored if DECODING or a non-audio stream.

Parameters

sampleRate

New sample rate (in Hz) to use.

Implements com::avpkit::core::IStreamCoder.

Definition at line 669 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened && val > 0)
    mCodecContext->sample_rate = val;
}

setStandardsCompliance()

int32_t com::avpkit::core::StreamCoder::setStandardsCompliance ( CodecStandardsCompliance  compliance )

virtual

Set the level of standards compliance.

Only paid attention to before the code is opened.

Parameters

compliance

The desired compliance level to set

Returns

0 on success; non-zero on failure

See also

CodecStandardsCompliance

Since

5.0

Implements com::avpkit::core::IStreamCoder.

Definition at line 2316 of file StreamCoder.cpp.

{
  if (!mCodecContext)
    return -1;
  mCodecContext->strict_std_compliance = compliance;
  return 0;
}

setTimeBase()

void com::avpkit::core::StreamCoder::setTimeBase ( IRational *  newTimeBase )

virtual

Set the time base we'll use to ENCODE with.

A no-op when DECODING.

As a convenience, we forward this call to the Stream::setTimeBase() method.

See also

getTimeBase()

Parameters

newTimeBase

The new time base to use.

Implements com::avpkit::core::IStreamCoder.

Definition at line 581 of file StreamCoder.cpp.

{
  if (mCodecContext && src && !mOpened)
  {
    mCodecContext->time_base.num = src->getNumerator();
    mCodecContext->time_base.den = src->getDenominator();
  }
  else
  {
    VS_LOG_INFO("Failed to setTimeBase on StreamCoder");
  }
}

References com::avpkit::core::IRational::getDenominator(), and com::avpkit::core::IRational::getNumerator().

setWidth()

void com::avpkit::core::StreamCoder::setWidth ( int32_t  width )

virtual

Set the width, in pixels.

See also

getWidth()

Parameters

width

Sets the width of video frames we'll encode. No-op when DECODING.

Implements com::avpkit::core::IStreamCoder.

Definition at line 552 of file StreamCoder.cpp.

{
  if (mCodecContext && !mOpened)
    mCodecContext->width = val;
}

---

The documentation for this class was generated from the following files:

• csrc/com/avpkit/core/StreamCoder.h
• csrc/com/avpkit/core/StreamCoder.cpp