PeerStreamer

 * Copyright(C) 2010,2011 Philip Langdale <ffmpeg.philipl@overt.org>

#include "h264.h"

    RET_ERROR           = -1,

    RET_OK              = 0,

    RET_COPY_AGAIN      = 1,

    RET_SKIP_NEXT_COPY  = 2,

    RET_COPY_NEXT_FIELD = 3,

    uint8_t pic_type;

    AVCodecParserContext *parser;

static uint64_t opaque_list_push(CHDContext *priv, uint64_t reordered_opaque,

                                 uint8_t pic_type)

    newNode->pic_type = pic_type;

static uint8_t opaque_list_pop(CHDContext *priv, uint64_t fake_timestamp,

                               uint64_t *reordered_opaque, uint8_t *pic_type)

        return FALSE;

        *reordered_opaque = node->reordered_opaque;

        *pic_type = node->pic_type;

        return TRUE;

            *reordered_opaque = node->reordered_opaque;

            *pic_type = node->pic_type;

            return TRUE;

    return FALSE;

    av_parser_close(priv->parser);

    if (avctx->codec->id == CODEC_ID_H264) {

        priv->parser = av_parser_init(avctx->codec->id);

        if (!priv->parser)

            av_log(avctx, AV_LOG_WARNING,

                   "Cannot open the h.264 parser! Interlaced h.264 content "

                   "will not be detected reliably.\n");

    }

 * Specifically, there are PAFF samples where input is always separate fields

 * but the hardware returns separate fields on one occasion and a field-pair

 * on another. The code assumes the first case and define

 * ASSUME_TWO_INPUTS_ONE_OUTPUT to assume the second case.

                                 void *data, int *data_size)

    uint8_t ignore_interlaced;

    int64_t pkt_pts  = AV_NOPTS_VALUE;

    uint8_t pic_type = 0;

    if (output->PicInfo.timeStamp != 0) {

        uint8_t pop_ret;

        pop_ret = opaque_list_pop(priv, output->PicInfo.timeStamp,

                                  &pkt_pts, &pic_type);

        if (!pop_ret) {

           /*

            * We will encounter a situation where a timestamp cannot be

            * popped if a second field is being returned. In this case,

            * each field has the same timestamp and the first one will

            * cause it to be popped. To keep subsequent calculations

            * simple, pic_type should be set a FIELD value - doesn't

            * matter which, but I chose BOTTOM.

            */

           pic_type = PICT_BOTTOM_FIELD;

        }

        av_log(avctx, AV_LOG_VERBOSE, "output \"pts\": %"PRIu64"\n",

               output->PicInfo.timeStamp);

        av_log(avctx, AV_LOG_VERBOSE, "output picture type %d\n",

               pic_type);

    }

    /*

     * Testing has, so far, shown that we can't trust the interlaced flag for

     * H.264 content when VDEC_FLAG_UNKNOWN_SRC is set.

     */

    ignore_interlaced = avctx->codec->id == CODEC_ID_H264 &&

                        (output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) &&

                        (pic_type == 0 || pic_type == PICT_FRAME ||

                         ASSUME_TWO_INPUTS_ONE_OUTPUT);

    interlaced        = (output->PicInfo.flags & VDEC_FLAG_INTERLACED_SRC) &&

                        !ignore_interlaced;

    av_log(avctx, AV_LOG_VERBOSE, "Interlaced state: %d | ignore_interlaced %d\n",

           interlaced, ignore_interlaced);

            dY++;

    priv->pic.pkt_pts = pkt_pts;

    /*

     * Testing has shown that in all cases where we don't want to return the

     * full frame immediately, VDEC_FLAG_UNKNOWN_SRC is set.

     */

    return priv->need_second_field &&

           !(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) ?

           RET_COPY_NEXT_FIELD : RET_OK;

                                    void *data, int *data_size)

            copy_ret = copy_frame(avctx, &output, data, data_size);

    uint8_t pic_type   = 0;

        if (priv->parser) {

            uint8_t *pout = NULL;

            int psize = len;

            H264Context *h = priv->parser->priv_data;

            while (psize) {

                ret = av_parser_parse2(priv->parser, avctx, &pout, &psize,

                                       avpkt->data, len, avctx->pkt->pts,

                                       avctx->pkt->dts, len - psize);

            }

            av_log(avctx, AV_LOG_VERBOSE,

                   "CrystalHD: parser picture type %d\n",

                   h->s.picture_structure);

            pic_type = h->s.picture_structure;

        }

            uint64_t pts = opaque_list_push(priv, avctx->pkt->pts, pic_type);

        rec_ret = receive_frame(avctx, data, data_size);

        if (rec_ret == RET_OK && *data_size == 0) {

            /*

             * This case is for when the encoded fields are stored

             * separately and we get a separate avpkt for each one. To keep

             * the pipeline stable, we should return nothing and wait for

             * the next time round to grab the second field.

             * H.264 PAFF is an example of this.

             */

            av_log(avctx, AV_LOG_VERBOSE, "Returning after first field.\n");

            avctx->has_b_frames--;

        } else if (rec_ret == RET_COPY_NEXT_FIELD) {

            /*

             * This case is for when the encoded fields are stored in a

             * single avpkt but the hardware returns then separately. Unless

             * we grab the second field before returning, we'll slip another

             * frame in the pipeline and if that happens a lot, we're sunk.

             * So we have to get that second field now.

             * Interlaced mpeg2 and vc1 are examples of this.

             */

            av_log(avctx, AV_LOG_VERBOSE, "Trying to get second field.\n");

            while (1) {

                usleep(priv->decode_wait);

                ret = DtsGetDriverStatus(dev, &decoder_status);

                if (ret == BC_STS_SUCCESS &&

                    decoder_status.ReadyListCount > 0) {

                    rec_ret = receive_frame(avctx, data, data_size);

                    if ((rec_ret == RET_OK && *data_size > 0) ||

                        rec_ret == RET_ERROR)

                        break;

            av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Got second field.\n");