自学教程：C++ AVUNERROR函数代码示例

int av_strerror(int errnum, char *errbuf, size_t errbuf_size){    int ret = 0, i;    const struct error_entry *entry = NULL;    for (i = 0; i < FF_ARRAY_ELEMS(error_entries); i++) {        if (errnum == error_entries[i].num) {            entry = &error_entries[i];            break;        }    }    if (entry) {        av_strlcpy(errbuf, entry->str, errbuf_size);    } else {#if HAVE_STRERROR_R        ret = AVERROR(strerror_r(AVUNERROR(errnum), errbuf, errbuf_size));#else        ret = -1;#endif        if (ret < 0)            snprintf(errbuf, errbuf_size, "Error number %d occurred", errnum);    }    return ret;}

/** Send a prepared MMST command packet. */static int send_command_packet(MMSTContext *mmst){    MMSContext *mms  = &mmst->mms;    int len= mms->write_out_ptr - mms->out_buffer;    int exact_length = FFALIGN(len, 8);    int first_length= exact_length - 16;    int len8= first_length/8;    int write_result;    // update packet length fields.    AV_WL32(mms->out_buffer + 8, first_length);    AV_WL32(mms->out_buffer + 16, len8);    AV_WL32(mms->out_buffer + 32, len8-2);    memset(mms->write_out_ptr, 0, exact_length - len);    // write it out.    write_result= ffurl_write(mms->mms_hd, mms->out_buffer, exact_length);    if(write_result != exact_length) {        av_log(NULL, AV_LOG_ERROR,               "Failed to write data of length %d: %d (%s)/n",               exact_length, write_result,               write_result < 0 ? strerror(AVUNERROR(write_result)) :                   "The server closed the connection");        return AVERROR(EIO);    }    return 0;}

int av_strerror(int errnum, char *errbuf, size_t errbuf_size){    int ret = 0;    const char *errstr = NULL;    switch (errnum) {    case AVERROR_BSF_NOT_FOUND:     errstr = "Bitstream filter not found"                   ; break;    case AVERROR_DECODER_NOT_FOUND: errstr = "Decoder not found"                            ; break;    case AVERROR_DEMUXER_NOT_FOUND: errstr = "Demuxer not found"                            ; break;    case AVERROR_ENCODER_NOT_FOUND: errstr = "Encoder not found"                            ; break;    case AVERROR_EOF:               errstr = "End of file"                                  ; break;    case AVERROR_EXIT:              errstr = "Immediate exit requested"                     ; break;    case AVERROR_FILTER_NOT_FOUND:  errstr = "Filter not found"                             ; break;    case AVERROR_INVALIDDATA:       errstr = "Invalid data found when processing input"     ; break;    case AVERROR_MUXER_NOT_FOUND:   errstr = "Muxer not found"                              ; break;    case AVERROR_OPTION_NOT_FOUND:  errstr = "Option not found"                             ; break;    case AVERROR_PATCHWELCOME:      errstr = "Not yet implemented in FFmpeg, patches welcome"; break;    case AVERROR_PROTOCOL_NOT_FOUND:errstr = "Protocol not found"                           ; break;    case AVERROR_STREAM_NOT_FOUND:  errstr = "Stream not found"                             ; break;    }    if (errstr) {        av_strlcpy(errbuf, errstr, errbuf_size);    } else {#if HAVE_STRERROR_R        ret = strerror_r(AVUNERROR(errnum), errbuf, errbuf_size);#else        ret = -1;#endif        if (ret < 0)            snprintf(errbuf, errbuf_size, "Error number %d occurred", errnum);    }    return ret;}

/***************************************************************************** * Write: *****************************************************************************/static ssize_t Write(sout_access_out_t *p_access, block_t *p_buffer){    sout_access_out_sys_t *p_sys = (sout_access_out_sys_t*)p_access->p_sys;    size_t i_write = 0;    int val;    while (p_buffer != NULL) {        block_t *p_next = p_buffer->p_next;        avio_write(p_sys->context, p_buffer->p_buffer, p_buffer->i_buffer);        avio_flush(p_sys->context);        if ((val = p_sys->context->error) != 0) {            p_sys->context->error = 0; /* FIXME? */            goto error;        }        i_write += p_buffer->i_buffer;        block_Release(p_buffer);        p_buffer = p_next;    }    return i_write;error:    msg_Err(p_access, "Wrote only %zu bytes: %s", i_write,            vlc_strerror_c(AVUNERROR(val)));    block_ChainRelease( p_buffer );    return i_write;}

static int mux_next(stream_t *stream){  int result;  AVPacket packet;  do {    result = get_next(stream);    if (result <= 0) {      return result;    }  } while (stream->dst_size == 0);  av_init_packet(&packet);  packet.data = stream->dst_data;  packet.size = stream->dst_size;  /*packet.pts = stream->pts;*/ /* FIXME: proper PTS/DTS handling */  packet.stream_index = 0;  result = av_interleaved_write_frame(stream->dst_ctx, &packet);  if (result < 0) {    musicd_log(LOG_ERROR, "stream",               "av_interleaved_write_frame failed: %s",               strerror(AVUNERROR(result)));    return -1;  }  return 1;}

int OutOpenAvio(vlc_object_t *object){    sout_access_out_t *access = (sout_access_out_t*)object;    config_ChainParse( access, "sout-avio-", ppsz_sout_options, access->p_cfg );    sout_access_out_sys_t *sys = malloc(sizeof(*sys));    if (!sys)        return VLC_ENOMEM;    sys->context = NULL;    /* */    vlc_init_avformat(object);    if (!access->psz_path)        goto error;    int ret;#if LIBAVFORMAT_VERSION_MAJOR < 54    ret = avio_open(&sys->context, access->psz_path, AVIO_FLAG_WRITE);#else    AVDictionary *options = NULL;    char *psz_opts = var_InheritString(access, "sout-avio-options");    if (psz_opts && *psz_opts) {        options = vlc_av_get_options(psz_opts);        free(psz_opts);    }    ret = avio_open2(&sys->context, access->psz_path, AVIO_FLAG_WRITE,                     NULL, &options);    AVDictionaryEntry *t = NULL;    while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX)))        msg_Err( access, "unknown option /"%s/"", t->key );    av_dict_free(&options);#endif    if (ret < 0) {        errno = AVUNERROR(ret);        msg_Err(access, "Failed to open %s", access->psz_path);        goto error;    }#if LIBAVFORMAT_VERSION_MAJOR < 54    /* We can accept only one active user at any time */    if (SetupAvioCb(VLC_OBJECT(access))) {        msg_Err(access, "Module aready in use");        goto error;    }#endif    access->pf_write = Write;    access->pf_control = OutControl;    access->pf_seek = OutSeek;    access->p_sys = sys;    return VLC_SUCCESS;error:    free(sys);    return VLC_EGENERIC;}

static void print_averror(int err) {  char errbuf[128];  const char *errbuf_ptr = errbuf;  if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)    errbuf_ptr = strerror(AVUNERROR(err));  fprintf(stderr, "%s/n", errbuf_ptr);}

void print_error(const char *filename, int err){    char errbuf[128];    const char *errbuf_ptr = errbuf;    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)        errbuf_ptr = strerror(AVUNERROR(err));    av_log(NULL, AV_LOG_ERROR, "%s: %s/n", filename, errbuf_ptr);}

void print_error(const char *filename, int err){    char errbuf[128];    const char *errbuf_ptr = errbuf;    if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)        errbuf_ptr = strerror(AVUNERROR(err));    fprintf(stderr, "%s: %s/n", filename, errbuf_ptr);}

int print_av_error(const char *function_name, int error) {	char errorbuf[128];	char *error_ptr = errorbuf;	if (av_strerror(error, errorbuf, sizeof(errorbuf)) < 0) {		error_ptr = strerror(AVUNERROR(error));	}	fprintf(stderr, "dr_meter: %s: %s/n", function_name, error_ptr);	return error;}

void PrintError(const wxString& msg, int err) {	char errbuf[128];	const char *errbuf_ptr = errbuf;		if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)		errbuf_ptr = strerror(AVUNERROR(err));	wxString errorStr(errbuf_ptr, wxConvUTF8);	wxLogError(msg + wxT(": ") + errorStr);}

/***************************************************************************** * Write: *****************************************************************************/static ssize_t Write(sout_access_out_t *p_access, block_t *p_buffer){    access_sys_t *p_sys = (access_sys_t*)p_access->p_sys;    size_t i_write = 0;    while (p_buffer != NULL) {        block_t *p_next = p_buffer->p_next;#if LIBAVFORMAT_VERSION_MAJOR < 54        int written = url_write(p_sys->context, p_buffer->p_buffer, p_buffer->i_buffer);        if (written < 0) {            errno = AVUNERROR(written);            goto error;        }        i_write += written;#else        avio_write(p_sys->context, p_buffer->p_buffer, p_buffer->i_buffer);        avio_flush(p_sys->context);        if (p_sys->context->error) {            errno = AVUNERROR(p_sys->context->error);            p_sys->context->error = 0; /* FIXME? */            goto error;        }        i_write += p_buffer->i_buffer;#endif        block_Release(p_buffer);        p_buffer = p_next;    }    return i_write;error:    msg_Err(p_access, "Wrote only %zu bytes (%m)", i_write);    block_ChainRelease( p_buffer );    return i_write;}

/***************************************************************************** * Mux: multiplex available data in input fifos *****************************************************************************/static int Mux( sout_mux_t *p_mux ){    sout_mux_sys_t *p_sys = p_mux->p_sys;    if( p_sys->b_error ) return VLC_EGENERIC;    if( p_sys->b_write_header )    {        int error;        msg_Dbg( p_mux, "writing header" );        char *psz_opts = var_GetNonEmptyString( p_mux, "sout-avformat-options" );        AVDictionary *options = NULL;        if (psz_opts) {            vlc_av_get_options(psz_opts, &options);            free(psz_opts);        }        av_dict_set( &p_sys->oc->metadata, "encoding_tool", "VLC "VERSION, 0 );        error = avformat_write_header( p_sys->oc, options ? &options : NULL);        AVDictionaryEntry *t = NULL;        while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {            msg_Err( p_mux, "Unknown option /"%s/"", t->key );        }        av_dict_free(&options);        if( error < 0 )        {            msg_Err( p_mux, "could not write header: %s",                     vlc_strerror_c(AVUNERROR(error)) );            p_sys->b_write_header = false;            p_sys->b_error = true;            return VLC_EGENERIC;        }        avio_flush( p_sys->oc->pb );        p_sys->b_write_header = false;    }    for( ;; )    {        mtime_t i_dts;        int i_stream = sout_MuxGetStream( p_mux, 1, &i_dts );        if( i_stream < 0 )            return VLC_SUCCESS;        MuxBlock( p_mux, p_mux->pp_inputs[i_stream] );    }    return VLC_SUCCESS;}

int ff_listen_connect(int fd, const struct sockaddr *addr,                      socklen_t addrlen, int timeout, URLContext *h,                      int will_try_next){    struct pollfd p = {fd, POLLOUT, 0};    int ret;    socklen_t optlen;    if (ff_socket_nonblock(fd, 1) < 0)        av_log(NULL, AV_LOG_DEBUG, "ff_socket_nonblock failed/n");    while ((ret = connect(fd, addr, addrlen))) {        ret = ff_neterrno();        switch (ret) {        case AVERROR(EINTR):            if (ff_check_interrupt(&h->interrupt_callback))                return AVERROR_EXIT;            continue;        case AVERROR(EINPROGRESS):        case AVERROR(EAGAIN):            ret = ff_poll_interrupt(&p, 1, timeout, &h->interrupt_callback);            if (ret < 0)                return ret;            optlen = sizeof(ret);            if (getsockopt (fd, SOL_SOCKET, SO_ERROR, &ret, &optlen))                ret = AVUNERROR(ff_neterrno());            if (ret != 0) {                char errbuf[100];                ret = AVERROR(ret);                av_strerror(ret, errbuf, sizeof(errbuf));                if (will_try_next)                    av_log(h, AV_LOG_WARNING,                           "Connection to %s failed (%s), trying next address/n",                           h->filename, errbuf);                else                    av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s/n",                           h->filename, errbuf);            }        default:            return ret;        }    }    return ret;}

int OutOpenAvio(vlc_object_t *object){    sout_access_out_t *access = (sout_access_out_t*)object;    config_ChainParse( access, "sout-avio-", ppsz_sout_options, access->p_cfg );    sout_access_out_sys_t *sys = vlc_obj_malloc(object, sizeof(*sys));    if (!sys)        return VLC_ENOMEM;    sys->context = NULL;    /* */    vlc_init_avformat(object);    if (!access->psz_path)        return VLC_EGENERIC;    int ret;    AVDictionary *options = NULL;    char *psz_opts = var_InheritString(access, "sout-avio-options");    if (psz_opts) {        vlc_av_get_options(psz_opts, &options);        free(psz_opts);    }    ret = avio_open2(&sys->context, access->psz_path, AVIO_FLAG_WRITE,                     NULL, &options);    AVDictionaryEntry *t = NULL;    while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX)))        msg_Err( access, "unknown option /"%s/"", t->key );    av_dict_free(&options);    if (ret < 0) {        errno = AVUNERROR(ret);        msg_Err(access, "Failed to open %s", access->psz_path);        return VLC_EGENERIC;    }    access->pf_write = Write;    access->pf_control = OutControl;    access->pf_seek = OutSeek;    access->p_sys = sys;    return VLC_SUCCESS;}

static OSStatus tls_write_cb(SSLConnectionRef connection, const void *data, size_t *dataLength){    URLContext *h = (URLContext*)connection;    TLSContext *c = h->priv_data;    int written = ffurl_write(c->tls_shared.tcp, data, *dataLength);    if (written <= 0) {        *dataLength = 0;        switch(AVUNERROR(written)) {            case EAGAIN:                return errSSLWouldBlock;            default:                c->lastErr = written;                return ioErr;        }    } else {        *dataLength = written;        return noErr;    }}

static int Seek(stream_t *access, uint64_t position){    access_sys_t *sys = access->p_sys;    int ret;#ifndef EOVERFLOW# define EOVERFLOW EFBIG#endif    if (position > INT64_MAX)        ret = AVERROR(EOVERFLOW);    else        ret = avio_seek(sys->context, position, SEEK_SET);    if (ret < 0) {        msg_Err(access, "Seek to %"PRIu64" failed: %s", position,                vlc_strerror_c(AVUNERROR(ret)));        if (sys->size < 0 || position != (uint64_t)sys->size)            return VLC_EGENERIC;    }    return VLC_SUCCESS;}

int open_radio( struct transcode_ctx *ctx, struct media_file_info *mfi ){    ctx->fmtctx = avformat_alloc_context();    URLContext *stream;    url_alloc(&stream, mfi->url, URL_RDONLY );    ff_http_set_headers( stream, "Icy-MetaData:1/r/n");    DPRINTF(E_DBG, L_XCODE, "Trying to open url %s/n", mfi->url);    int ret = url_connect(stream);    if (ret != 0)    {        DPRINTF(E_WARN, L_XCODE, "Could not open url %s: %s/n", mfi->url, strerror(AVUNERROR(ret)));        return -1;    }    DPRINTF(E_DBG, L_XCODE, "URL opened successfully");    if (icy)        free(icy);    icy = (struct icy_ctx *)malloc(sizeof(struct icy_ctx));    icy->context = stream;    icy->data_pos = 0;    icy->icy_metaint = get_meta_int( stream );    icy->rewritten_album = 0;    icy->mfi = mfi;    ctx->fmtctx = avformat_alloc_context();    if (buff)        av_free( buff );    buff = (uint8_t *) av_malloc( BIO_BUFFER_SIZE );    ctx->fmtctx->pb = avio_alloc_context(buff, BIO_BUFFER_SIZE, 0, icy, ReadFunc2, NULL, NULL);    return avformat_open_input(&ctx->fmtctx, mfi->url, NULL, NULL);}

static int unix_open(URLContext *h, const char *filename, int flags){    UnixContext *s = h->priv_data;    int fd, ret;    av_strstart(filename, "unix:", &filename);    s->addr.sun_family = AF_UNIX;    av_strlcpy(s->addr.sun_path, filename, sizeof(s->addr.sun_path));    if ((fd = ff_socket(AF_UNIX, s->type, 0)) < 0)        return ff_neterrno();    if (s->timeout < 0 && h->rw_timeout)        s->timeout = h->rw_timeout / 1000;    if (s->listen) {        ret = ff_listen_bind(fd, (struct sockaddr *)&s->addr,                             sizeof(s->addr), s->timeout, h);        if (ret < 0)            goto fail;        fd = ret;    } else {        ret = ff_listen_connect(fd, (struct sockaddr *)&s->addr,                                sizeof(s->addr), s->timeout, h, 0);        if (ret < 0)            goto fail;    }    s->fd = fd;    return 0;fail:    if (s->listen && AVUNERROR(ret) != EADDRINUSE)        unlink(s->addr.sun_path);    if (fd >= 0)        closesocket(fd);    return ret;}

static int Seek(access_t *access, uint64_t position){    access_sys_t *sys = access->p_sys;    int ret;#ifndef EOVERFLOW# define EOVERFLOW EFBIG#endif    if (position > INT64_MAX)        ret = AVERROR(EOVERFLOW);    else        ret = avio_seek(sys->context, position, SEEK_SET);    if (ret < 0) {        errno = AVUNERROR(ret);        msg_Err(access, "Seek to %"PRIu64" failed: %m", position);        if (sys->size == 0 || position != sys->size)            return VLC_EGENERIC;    }    access->info.i_pos = position;    access->info.b_eof = false;    return VLC_SUCCESS;}

static int encode_next(stream_t *stream){  int result, got_packet;  AVFrame *frame = stream->encode_frame;  AVPacket *packet = &stream->encode_packet;  while (av_audio_fifo_size(stream->src_buf) < stream->encoder->frame_size) {    result = decode_next(stream);    if (result <= 0) {      return result;    }  }  av_audio_fifo_read(stream->src_buf,                     (void **)frame->extended_data,                     stream->encoder->frame_size);  av_free_packet(packet);  result = avcodec_encode_audio2(stream->encoder, packet, frame, &got_packet);  if (result < 0) {    musicd_log(LOG_ERROR, "stream", "can't encode: %s",               strerror(AVUNERROR(result)));    return -1;  }  if (!got_packet) {    return 1;  }  stream->dst_data = packet->data;  stream->dst_size = packet->size;  return 1;}

static OSStatus tls_read_cb(SSLConnectionRef connection, void *data, size_t *dataLength){    URLContext *h = (URLContext*)connection;    TLSContext *c = h->priv_data;    int read = ffurl_read_complete(c->tls_shared.tcp, data, *dataLength);    if (read <= 0) {        *dataLength = 0;        switch(AVUNERROR(read)) {            case ENOENT:            case 0:                return errSSLClosedGraceful;            case ECONNRESET:                return errSSLClosedAbort;            case EAGAIN:                return errSSLWouldBlock;            default:                c->lastErr = read;                return ioErr;        }    } else {        *dataLength = read;        return noErr;    }}

static int read_next(stream_t *stream){  int result;    while (1) {    av_free_packet(&stream->src_packet);    result = av_read_frame(stream->src_ctx, &stream->src_packet);    if (result < 0) {      if (result == AVERROR_EOF) {        /* end of file */        return 0;      }      musicd_log(LOG_ERROR, "stream", "av_read_frame failed: %s",                 strerror(AVUNERROR(result)));      return 0;    }    if (stream->src_packet.stream_index != 0) {      continue;    }    break;  }  if (stream->src_packet.pts * av_q2d(stream->src_ctx->streams[0]->time_base) >      stream->track->start + stream->track->duration) {    if (stream->track->cuefile) {      /* Accurate end of track */      return 0;    } else {      /* Miscalculated track length */    }  }    return 1;}

int OpenAvio(vlc_object_t *object){    stream_t *access = (stream_t*)object;    access_sys_t *sys = vlc_obj_malloc(object, sizeof(*sys));    if (!sys)        return VLC_ENOMEM;    sys->context = NULL;    /* We accept:     * - avio://full_url     * - url (only a subset of available protocols).     */    char *url;    if (!strcmp(access->psz_name, "avio"))        url = strdup(access->psz_location);    else if (asprintf(&url, "%s://%s", access->psz_name,                      access->psz_location) < 0)        url = NULL;    if (!url)        return VLC_ENOMEM;    /* */    vlc_init_avformat(object);    int ret;    AVIOInterruptCB cb = {        .callback = UrlInterruptCallback,        .opaque = access,    };    AVDictionary *options = NULL;    char *psz_opts = var_InheritString(access, "avio-options");    if (psz_opts) {        vlc_av_get_options(psz_opts, &options);        free(psz_opts);    }    ret = avio_open2(&sys->context, url, AVIO_FLAG_READ, &cb, &options);    AVDictionaryEntry *t = NULL;    while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX)))        msg_Err( access, "unknown option /"%s/"", t->key );    av_dict_free(&options);    if (ret < 0) {        msg_Err(access, "Failed to open %s: %s", url,                vlc_strerror_c(AVUNERROR(ret)));        free(url);        return VLC_EGENERIC;    }    free(url);    sys->size = avio_size(sys->context);    bool seekable;    seekable = sys->context->seekable;    msg_Dbg(access, "%sseekable, size=%"PRIi64, seekable ? "" : "not ",            sys->size);    /* */    access->pf_read = Read;    access->pf_block = NULL;    access->pf_control = Control;    access->pf_seek = Seek;    access->p_sys = sys;    return VLC_SUCCESS;}

/** Read incoming MMST media, header or command packet. */static MMSSCPacketType get_tcp_server_response(MMSTContext *mmst){    int read_result;    MMSSCPacketType packet_type= -1;    MMSContext *mms = &mmst->mms;    for(;;) {        read_result = ffurl_read_complete(mms->mms_hd, mms->in_buffer, 8);        if (read_result != 8) {            if(read_result < 0) {                av_log(NULL, AV_LOG_ERROR,                       "Error reading packet header: %d (%s)/n",                       read_result, strerror(AVUNERROR(read_result)));                packet_type = SC_PKT_CANCEL;            } else {                av_log(NULL, AV_LOG_ERROR,                       "The server closed the connection/n");                packet_type = SC_PKT_NO_DATA;            }            return packet_type;        }        // handle command packet.        if(AV_RL32(mms->in_buffer + 4)==0xb00bface) {            int length_remaining, hr;            mmst->incoming_flags= mms->in_buffer[3];            read_result= ffurl_read_complete(mms->mms_hd, mms->in_buffer+8, 4);            if(read_result != 4) {                av_log(NULL, AV_LOG_ERROR,                       "Reading command packet length failed: %d (%s)/n",                       read_result,                       read_result < 0 ? strerror(AVUNERROR(read_result)) :                           "The server closed the connection");                return read_result < 0 ? read_result : AVERROR(EIO);            }            length_remaining= AV_RL32(mms->in_buffer+8) + 4;            av_log(NULL, AV_LOG_TRACE, "Length remaining is %d/n", length_remaining);            // read the rest of the packet.            if (length_remaining < 0                || length_remaining > sizeof(mms->in_buffer) - 12) {                av_log(NULL, AV_LOG_ERROR,                       "Incoming packet length %d exceeds bufsize %"SIZE_SPECIFIER"/n",                       length_remaining, sizeof(mms->in_buffer) - 12);                return AVERROR_INVALIDDATA;            }            read_result = ffurl_read_complete(mms->mms_hd, mms->in_buffer + 12,                                            length_remaining) ;            if (read_result != length_remaining) {                av_log(NULL, AV_LOG_ERROR,                       "Reading pkt data (length=%d) failed: %d (%s)/n",                       length_remaining, read_result,                       read_result < 0 ? strerror(AVUNERROR(read_result)) :                           "The server closed the connection");                return read_result < 0 ? read_result : AVERROR(EIO);            }            packet_type= AV_RL16(mms->in_buffer+36);            if (read_result >= 44 && (hr = AV_RL32(mms->in_buffer + 40))) {                av_log(NULL, AV_LOG_ERROR,                       "Server sent a message with packet type 0x%x and error status code 0x%08x/n", packet_type, hr);                return AVERROR(EINVAL);            }        } else {            int length_remaining;            int packet_id_type;            int tmp;            // note we cache the first 8 bytes,            // then fill up the buffer with the others            tmp                       = AV_RL16(mms->in_buffer + 6);            length_remaining          = (tmp - 8) & 0xffff;            mmst->incoming_packet_seq = AV_RL32(mms->in_buffer);            packet_id_type            = mms->in_buffer[4];            mmst->incoming_flags      = mms->in_buffer[5];            if (length_remaining < 0                || length_remaining > sizeof(mms->in_buffer) - 8) {                av_log(NULL, AV_LOG_ERROR,                       "Data length %d is invalid or too large (max=%"SIZE_SPECIFIER")/n",                       length_remaining, sizeof(mms->in_buffer));                return AVERROR_INVALIDDATA;            }            mms->remaining_in_len    = length_remaining;            mms->read_in_ptr         = mms->in_buffer;            read_result= ffurl_read_complete(mms->mms_hd, mms->in_buffer, length_remaining);            if(read_result != length_remaining) {                av_log(NULL, AV_LOG_ERROR,                       "Failed to read packet data of size %d: %d (%s)/n",                       length_remaining, read_result,                       read_result < 0 ? strerror(AVUNERROR(read_result)) :                           "The server closed the connection");                return read_result < 0 ? read_result : AVERROR(EIO);            }            // if we successfully read everything.            if(packet_id_type == mmst->header_packet_id) {                int err;                packet_type = SC_PKT_ASF_HEADER;                // Store the asf header//.........这里部分代码省略.........

intscan_metadata_ffmpeg(char *file, struct media_file_info *mfi){  AVFormatContext *ctx;  const struct metadata_map *extra_md_map;  enum CodecID codec_id;  enum CodecID video_codec_id;  enum CodecID audio_codec_id;  AVStream *video_stream;  AVStream *audio_stream;  int mdcount;  int i;  int ret;  ctx = NULL;#if LIBAVFORMAT_VERSION_MAJOR >= 53 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVCODEC_VERSION_MINOR >= 3)  ret = avformat_open_input(&ctx, file, NULL, NULL);#else  ret = av_open_input_file(&ctx, file, NULL, 0, NULL);#endif  if (ret != 0)    {      DPRINTF(E_WARN, L_SCAN, "Cannot open media file '%s': %s/n", file, strerror(AVUNERROR(ret)));      return -1;    }  ret = av_find_stream_info(ctx);  if (ret < 0)    {      DPRINTF(E_WARN, L_SCAN, "Cannot get stream info: %s/n", strerror(AVUNERROR(ret)));      av_close_input_file(ctx);      return -1;    }#if 0  /* Dump input format as determined by ffmpeg */# if LIBAVFORMAT_VERSION_MAJOR >= 52 || (LIBAVFORMAT_VERSION_MAJOR == 52 && LIBAVCODEC_VERSION_MINOR >= 101)  av_dump_format(ctx, 0, file, 0);# else  dump_format(ctx, 0, file, FALSE);# endif#endif  DPRINTF(E_DBG, L_SCAN, "File has %d streams/n", ctx->nb_streams);  /* Extract codec IDs, check for video */  video_codec_id = CODEC_ID_NONE;  video_stream = NULL;  audio_codec_id = CODEC_ID_NONE;  audio_stream = NULL;  for (i = 0; i < ctx->nb_streams; i++)    {      switch (ctx->streams[i]->codec->codec_type)	{#if LIBAVCODEC_VERSION_MAJOR >= 53 || (LIBAVCODEC_VERSION_MAJOR == 52 && LIBAVCODEC_VERSION_MINOR >= 64)	  case AVMEDIA_TYPE_VIDEO:#else	  case CODEC_TYPE_VIDEO:#endif	    if (!video_stream)	      {		DPRINTF(E_DBG, L_SCAN, "File has video (stream %d)/n", i);		mfi->has_video = 1;		video_stream = ctx->streams[i];		video_codec_id = video_stream->codec->codec_id;	      }	    break;#if LIBAVCODEC_VERSION_MAJOR >= 53 || (LIBAVCODEC_VERSION_MAJOR == 52 && LIBAVCODEC_VERSION_MINOR >= 64)	  case AVMEDIA_TYPE_AUDIO:#else	  case CODEC_TYPE_AUDIO:#endif	    if (!audio_stream)	      {		audio_stream = ctx->streams[i];		audio_codec_id = audio_stream->codec->codec_id;	      } 	    break;	  default:	    break;	}    }  if (audio_codec_id == CODEC_ID_NONE)    {      DPRINTF(E_DBG, L_SCAN, "File has no audio streams, discarding/n");      av_close_input_file(ctx);      return -1;    }  /* Common media information *///.........这里部分代码省略.........

intscan_metadata_ffmpeg(char *file, struct media_file_info *mfi){  AVFormatContext *ctx;  AVDictionary *options;  const struct metadata_map *extra_md_map;  struct http_icy_metadata *icy_metadata;#if LIBAVCODEC_VERSION_MAJOR >= 55 || (LIBAVCODEC_VERSION_MAJOR == 54 && LIBAVCODEC_VERSION_MINOR >= 35)  enum AVCodecID codec_id;  enum AVCodecID video_codec_id;  enum AVCodecID audio_codec_id;#else  enum CodecID codec_id;  enum CodecID video_codec_id;  enum CodecID audio_codec_id;#endif  AVStream *video_stream;  AVStream *audio_stream;  char *path;  int mdcount;  int i;  int ret;  ctx = NULL;  options = NULL;  path = strdup(file);#if LIBAVFORMAT_VERSION_MAJOR >= 54 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR >= 3)# ifndef HAVE_FFMPEG  // Without this, libav is slow to probe some internet streams  if (mfi->data_kind == DATA_KIND_HTTP)    {      ctx = avformat_alloc_context();      ctx->probesize = 64000;    }# endif  if (mfi->data_kind == DATA_KIND_HTTP)    {      free(path);      ret = http_stream_setup(&path, file);      if (ret < 0)	return -1;      av_dict_set(&options, "icy", "1", 0);      mfi->artwork = ARTWORK_HTTP;    }  ret = avformat_open_input(&ctx, path, NULL, &options);  if (options)    av_dict_free(&options);#else  ret = av_open_input_file(&ctx, path, NULL, 0, NULL);#endif  if (ret != 0)    {      DPRINTF(E_WARN, L_SCAN, "Cannot open media file '%s': %s/n", path, strerror(AVUNERROR(ret)));      free(path);      return -1;    }  free(path);#if LIBAVFORMAT_VERSION_MAJOR >= 54 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR >= 3)  ret = avformat_find_stream_info(ctx, NULL);#else  ret = av_find_stream_info(ctx);#endif  if (ret < 0)    {      DPRINTF(E_WARN, L_SCAN, "Cannot get stream info: %s/n", strerror(AVUNERROR(ret)));#if LIBAVFORMAT_VERSION_MAJOR >= 54 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR >= 21)      avformat_close_input(&ctx);#else      av_close_input_file(ctx);#endif      return -1;    }#if 0  /* Dump input format as determined by ffmpeg */  av_dump_format(ctx, 0, file, 0);#endif  DPRINTF(E_DBG, L_SCAN, "File has %d streams/n", ctx->nb_streams);  /* Extract codec IDs, check for video */#if LIBAVCODEC_VERSION_MAJOR >= 55 || (LIBAVCODEC_VERSION_MAJOR == 54 && LIBAVCODEC_VERSION_MINOR >= 35)  video_codec_id = AV_CODEC_ID_NONE;  video_stream = NULL;  audio_codec_id = AV_CODEC_ID_NONE;  audio_stream = NULL;#else  video_codec_id = CODEC_ID_NONE;  video_stream = NULL;//.........这里部分代码省略.........