AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT, // LRrs
AV_CH_BACK_CENTER, // Cs
- AV_CH_TOP_BACK_CENTER, // Ts
- AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, // LRsd
+ AV_CH_TOP_CENTER, // Ts
+ AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT, // LRsd - TODO: Surround Direct
- AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER, // LRw - TODO: Wide
+ AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT, // LRw
AV_CH_TOP_FRONT_CENTER, // Cvh
AV_CH_LOW_FREQUENCY // LFE2
};
return channels;
}
-static uint64_t truehd_layout(int chanmap)
+uint64_t ff_truehd_layout(int chanmap)
{
- int layout = 0, i;
+ int i;
+ uint64_t layout = 0;
for (i = 0; i < 13; i++)
layout |= thd_layout[i] * ((chanmap >> i) & 1);
OBJS-$(CONFIG_H264_DEMUXER) += h264dec.o rawdec.o
OBJS-$(CONFIG_H264_MUXER) += rawenc.o
OBJS-$(CONFIG_HLS_DEMUXER) += hls.o
+OBJS-$(CONFIG_ICO_DEMUXER) += icodec.o
OBJS-$(CONFIG_IDCIN_DEMUXER) += idcin.o
+OBJS-$(CONFIG_IDF_DEMUXER) += bintext.o
OBJS-$(CONFIG_IFF_DEMUXER) += iff.o
- OBJS-$(CONFIG_IMAGE2_DEMUXER) += img2.o
- OBJS-$(CONFIG_IMAGE2_MUXER) += img2.o
- OBJS-$(CONFIG_IMAGE2PIPE_DEMUXER) += img2.o
- OBJS-$(CONFIG_IMAGE2PIPE_MUXER) += img2.o
+ OBJS-$(CONFIG_IMAGE2_DEMUXER) += img2dec.o img2.o
+ OBJS-$(CONFIG_IMAGE2_MUXER) += img2enc.o img2.o
+ OBJS-$(CONFIG_IMAGE2PIPE_DEMUXER) += img2dec.o img2.o
+ OBJS-$(CONFIG_IMAGE2PIPE_MUXER) += img2enc.o img2.o
OBJS-$(CONFIG_INGENIENT_DEMUXER) += ingenientdec.o rawdec.o
OBJS-$(CONFIG_IPMOVIE_DEMUXER) += ipmovie.o
OBJS-$(CONFIG_ISS_DEMUXER) += iss.o
return 0;
}
+ if (s->flags & AVFMT_FLAG_IGNIDX)
+ return 0;
+
while (avio_tell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
- int64_t* current_array;
+ int64_t** current_array;
+ unsigned int arraylen;
// Expect array object in context
if (avio_r8(ioc) != AMF_DATA_TYPE_ARRAY)
}
}
- if (!ret && timeslen == fileposlen)
- for (i = 0; i < fileposlen; i++)
+ if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) {
+ int64_t dts, size0, size1;
+ avio_seek(ioc, filepositions[1]-4, SEEK_SET);
+ size0 = avio_rb32(ioc);
+ avio_r8(ioc);
+ size1 = avio_rb24(ioc);
+ dts = avio_rb24(ioc);
+ dts |= avio_r8(ioc) << 24;
+ if (size0 > filepositions[1] || FFABS(dts - times[1]*1000)>5000/*arbitraray threshold to detect invalid index*/)
+ goto invalid;
- for(i = 0; i < timeslen; i++)
- av_add_index_entry(vstream, filepositions[i], times[i]*1000, 0, 0, AVINDEX_KEYFRAME);
++ for(i = 0; i < timeslen; i++)
+ av_add_index_entry(vstream, filepositions[i], times[i]*1000,
+ 0, 0, AVINDEX_KEYFRAME);
- else
+ } else {
+invalid:
av_log(s, AV_LOG_WARNING, "Invalid keyframes object, skipping.\n");
+ }
finish:
av_freep(×);
--- /dev/null
- * This file is part of Libav.
+ /*
+ * Image format
+ * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
+ * Copyright (c) 2004 Michael Niedermayer
+ *
- * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+ *
- * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
- * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
- if(codec->codec_id != CODEC_ID_RAWVIDEO)
++ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+ #include "libavutil/avstring.h"
+ #include "libavutil/log.h"
+ #include "libavutil/opt.h"
+ #include "libavutil/pixdesc.h"
+ #include "libavutil/parseutils.h"
+ #include "avformat.h"
+ #include "internal.h"
+
+ typedef struct {
+ const AVClass *class; /**< Class for private options. */
+ int img_first;
+ int img_last;
+ int img_number;
+ int img_count;
+ int is_pipe;
++ int split_planes; /**< use independent file for each Y, U, V plane */
+ char path[1024];
+ char *pixel_format; /**< Set by a private option. */
+ char *video_size; /**< Set by a private option. */
+ char *framerate; /**< Set by a private option. */
+ int loop;
+ } VideoDemuxData;
+
+ static const int sizes[][2] = {
+ { 640, 480 },
+ { 720, 480 },
+ { 720, 576 },
+ { 352, 288 },
+ { 352, 240 },
+ { 160, 128 },
+ { 512, 384 },
+ { 640, 352 },
+ { 640, 240 },
+ };
+
+ static int infer_size(int *width_ptr, int *height_ptr, int size)
+ {
+ int i;
+
+ for(i=0;i<FF_ARRAY_ELEMS(sizes);i++) {
+ if ((sizes[i][0] * sizes[i][1]) == size) {
+ *width_ptr = sizes[i][0];
+ *height_ptr = sizes[i][1];
+ return 0;
+ }
+ }
+ return -1;
+ }
+
+ /* return -1 if no image found */
+ static int find_image_range(int *pfirst_index, int *plast_index,
+ const char *path)
+ {
+ char buf[1024];
+ int range, last_index, range1, first_index;
+
+ /* find the first image */
+ for(first_index = 0; first_index < 5; first_index++) {
+ if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0){
+ *pfirst_index =
+ *plast_index = 1;
+ if (avio_check(buf, AVIO_FLAG_READ) > 0)
+ return 0;
+ return -1;
+ }
+ if (avio_check(buf, AVIO_FLAG_READ) > 0)
+ break;
+ }
+ if (first_index == 5)
+ goto fail;
+
+ /* find the last image */
+ last_index = first_index;
+ for(;;) {
+ range = 0;
+ for(;;) {
+ if (!range)
+ range1 = 1;
+ else
+ range1 = 2 * range;
+ if (av_get_frame_filename(buf, sizeof(buf), path,
+ last_index + range1) < 0)
+ goto fail;
+ if (avio_check(buf, AVIO_FLAG_READ) <= 0)
+ break;
+ range = range1;
+ /* just in case... */
+ if (range >= (1 << 30))
+ goto fail;
+ }
+ /* we are sure than image last_index + range exists */
+ if (!range)
+ break;
+ last_index += range;
+ }
+ *pfirst_index = first_index;
+ *plast_index = last_index;
+ return 0;
+ fail:
+ return -1;
+ }
+
+
+ static int read_probe(AVProbeData *p)
+ {
+ if (p->filename && ff_guess_image2_codec(p->filename)) {
+ if (av_filename_number_test(p->filename))
+ return AVPROBE_SCORE_MAX;
+ else
+ return AVPROBE_SCORE_MAX/2;
+ }
+ return 0;
+ }
+
+ static int read_header(AVFormatContext *s1)
+ {
+ VideoDemuxData *s = s1->priv_data;
+ int first_index, last_index, ret = 0;
+ int width = 0, height = 0;
+ AVStream *st;
+ enum PixelFormat pix_fmt = PIX_FMT_NONE;
+ AVRational framerate;
+
+ s1->ctx_flags |= AVFMTCTX_NOHEADER;
+
+ st = avformat_new_stream(s1, NULL);
+ if (!st) {
+ return AVERROR(ENOMEM);
+ }
+
+ if (s->pixel_format && (pix_fmt = av_get_pix_fmt(s->pixel_format)) == PIX_FMT_NONE) {
+ av_log(s1, AV_LOG_ERROR, "No such pixel format: %s.\n", s->pixel_format);
+ return AVERROR(EINVAL);
+ }
+ if (s->video_size && (ret = av_parse_video_size(&width, &height, s->video_size)) < 0) {
+ av_log(s, AV_LOG_ERROR, "Could not parse video size: %s.\n", s->video_size);
+ return ret;
+ }
+ if ((ret = av_parse_video_rate(&framerate, s->framerate)) < 0) {
+ av_log(s, AV_LOG_ERROR, "Could not parse framerate: %s.\n", s->framerate);
+ return ret;
+ }
+
+ av_strlcpy(s->path, s1->filename, sizeof(s->path));
+ s->img_number = 0;
+ s->img_count = 0;
+
+ /* find format */
+ if (s1->iformat->flags & AVFMT_NOFILE)
+ s->is_pipe = 0;
+ else{
+ s->is_pipe = 1;
+ st->need_parsing = AVSTREAM_PARSE_FULL;
+ }
+
+ avpriv_set_pts_info(st, 60, framerate.den, framerate.num);
+
+ if (width && height) {
+ st->codec->width = width;
+ st->codec->height = height;
+ }
+
+ if (!s->is_pipe) {
+ if (find_image_range(&first_index, &last_index, s->path) < 0)
+ return AVERROR(ENOENT);
+ s->img_first = first_index;
+ s->img_last = last_index;
+ s->img_number = first_index;
+ /* compute duration */
+ st->start_time = 0;
+ st->duration = last_index - first_index + 1;
+ }
+
+ if(s1->video_codec_id){
+ st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+ st->codec->codec_id = s1->video_codec_id;
+ }else if(s1->audio_codec_id){
+ st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+ st->codec->codec_id = s1->audio_codec_id;
+ }else{
++ const char *str= strrchr(s->path, '.');
++ s->split_planes = str && !av_strcasecmp(str + 1, "y");
+ st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+ st->codec->codec_id = ff_guess_image2_codec(s->path);
++ if (st->codec->codec_id == CODEC_ID_LJPEG)
++ st->codec->codec_id = CODEC_ID_MJPEG;
+ }
+ if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pix_fmt != PIX_FMT_NONE)
+ st->codec->pix_fmt = pix_fmt;
+
+ return 0;
+ }
+
+ static int read_packet(AVFormatContext *s1, AVPacket *pkt)
+ {
+ VideoDemuxData *s = s1->priv_data;
+ char filename[1024];
+ int i;
+ int size[3]={0}, ret[3]={0};
+ AVIOContext *f[3];
+ AVCodecContext *codec= s1->streams[0]->codec;
+
+ if (!s->is_pipe) {
+ /* loop over input */
+ if (s->loop && s->img_number > s->img_last) {
+ s->img_number = s->img_first;
+ }
+ if (s->img_number > s->img_last)
+ return AVERROR_EOF;
+ if (av_get_frame_filename(filename, sizeof(filename),
+ s->path, s->img_number)<0 && s->img_number > 1)
+ return AVERROR(EIO);
+ for(i=0; i<3; i++){
+ if (avio_open2(&f[i], filename, AVIO_FLAG_READ,
+ &s1->interrupt_callback, NULL) < 0) {
+ if(i==1)
+ break;
+ av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",filename);
+ return AVERROR(EIO);
+ }
+ size[i]= avio_size(f[i]);
+
- if (f[0]->eof_reached)
++ if(!s->split_planes)
+ break;
+ filename[ strlen(filename) - 1 ]= 'U' + i;
+ }
+
+ if(codec->codec_id == CODEC_ID_RAWVIDEO && !codec->width)
+ infer_size(&codec->width, &codec->height, size[0]);
+ } else {
+ f[0] = s1->pb;
++ if (url_feof(f[0]))
+ return AVERROR(EIO);
+ size[0]= 4096;
+ }
+
+ av_new_packet(pkt, size[0] + size[1] + size[2]);
+ pkt->stream_index = 0;
+ pkt->flags |= AV_PKT_FLAG_KEY;
+
+ pkt->size= 0;
+ for(i=0; i<3; i++){
+ if(size[i]){
+ ret[i]= avio_read(f[i], pkt->data + pkt->size, size[i]);
+ if (!s->is_pipe)
+ avio_close(f[i]);
+ if(ret[i]>0)
+ pkt->size += ret[i];
+ }
+ }
+
+ if (ret[0] <= 0 || ret[1]<0 || ret[2]<0) {
+ av_free_packet(pkt);
+ return AVERROR(EIO); /* signal EOF */
+ } else {
+ s->img_count++;
+ s->img_number++;
+ return 0;
+ }
+ }
+
+ #define OFFSET(x) offsetof(VideoDemuxData, x)
+ #define DEC AV_OPT_FLAG_DECODING_PARAM
+ static const AVOption options[] = {
+ { "pixel_format", "", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
+ { "video_size", "", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
+ { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC },
+ { "loop", "", OFFSET(loop), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 1, DEC },
+ { NULL },
+ };
+
+ #if CONFIG_IMAGE2_DEMUXER
+ static const AVClass img2_class = {
+ .class_name = "image2 demuxer",
+ .item_name = av_default_item_name,
+ .option = options,
+ .version = LIBAVUTIL_VERSION_INT,
+ };
+ AVInputFormat ff_image2_demuxer = {
+ .name = "image2",
+ .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
+ .priv_data_size = sizeof(VideoDemuxData),
+ .read_probe = read_probe,
+ .read_header = read_header,
+ .read_packet = read_packet,
+ .flags = AVFMT_NOFILE,
+ .priv_class = &img2_class,
+ };
+ #endif
+ #if CONFIG_IMAGE2PIPE_DEMUXER
+ static const AVClass img2pipe_class = {
+ .class_name = "image2pipe demuxer",
+ .item_name = av_default_item_name,
+ .option = options,
+ .version = LIBAVUTIL_VERSION_INT,
+ };
+ AVInputFormat ff_image2pipe_demuxer = {
+ .name = "image2pipe",
+ .long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
+ .priv_data_size = sizeof(VideoDemuxData),
+ .read_header = read_header,
+ .read_packet = read_packet,
+ .priv_class = &img2pipe_class,
+ };
+ #endif
--- /dev/null
- * This file is part of Libav.
+ /*
+ * Image format
+ * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
+ * Copyright (c) 2004 Michael Niedermayer
+ *
- * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+ *
- * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
- * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
- img->path, img->img_number) < 0 && img->img_number>1) {
++ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+ #include "libavutil/intreadwrite.h"
+ #include "libavutil/avstring.h"
+ #include "libavutil/log.h"
++#include "libavutil/opt.h"
+ #include "avformat.h"
+ #include "avio_internal.h"
+ #include "internal.h"
+
+ typedef struct {
++ const AVClass *class; /**< Class for private options. */
+ int img_number;
+ int is_pipe;
++ int split_planes; /**< use independent file for each Y, U, V plane */
+ char path[1024];
++ int updatefirst;
+ } VideoMuxData;
+
+ static int write_header(AVFormatContext *s)
+ {
+ VideoMuxData *img = s->priv_data;
++ const char *str;
+
+ img->img_number = 1;
+ av_strlcpy(img->path, s->filename, sizeof(img->path));
+
+ /* find format */
+ if (s->oformat->flags & AVFMT_NOFILE)
+ img->is_pipe = 0;
+ else
+ img->is_pipe = 1;
+
++ str = strrchr(img->path, '.');
++ img->split_planes = str && !av_strcasecmp(str + 1, "y");
+ return 0;
+ }
+
+ static int write_packet(AVFormatContext *s, AVPacket *pkt)
+ {
+ VideoMuxData *img = s->priv_data;
+ AVIOContext *pb[3];
+ char filename[1024];
+ AVCodecContext *codec= s->streams[ pkt->stream_index ]->codec;
+ int i;
+
+ if (!img->is_pipe) {
+ if (av_get_frame_filename(filename, sizeof(filename),
- return AVERROR(EIO);
++ img->path, img->img_number) < 0 && img->img_number>1 && !img->updatefirst) {
+ av_log(s, AV_LOG_ERROR,
+ "Could not get frame filename number %d from pattern '%s'\n",
+ img->img_number, img->path);
- if(codec->codec_id != CODEC_ID_RAWVIDEO)
++ return AVERROR(EINVAL);
+ }
+ for(i=0; i<3; i++){
+ if (avio_open2(&pb[i], filename, AVIO_FLAG_WRITE,
+ &s->interrupt_callback, NULL) < 0) {
+ av_log(s, AV_LOG_ERROR, "Could not open file : %s\n",filename);
+ return AVERROR(EIO);
+ }
+
- if(codec->codec_id == CODEC_ID_RAWVIDEO){
++ if(!img->split_planes)
+ break;
+ filename[ strlen(filename) - 1 ]= 'U' + i;
+ }
+ } else {
+ pb[0] = s->pb;
+ }
+
- av_log(s, AV_LOG_ERROR, "malformed JPEG 2000 codestream\n");
++ if(img->split_planes){
+ int ysize = codec->width * codec->height;
+ avio_write(pb[0], pkt->data , ysize);
+ avio_write(pb[1], pkt->data + ysize, (pkt->size - ysize)/2);
+ avio_write(pb[2], pkt->data + ysize +(pkt->size - ysize)/2, (pkt->size - ysize)/2);
+ avio_flush(pb[1]);
+ avio_flush(pb[2]);
+ avio_close(pb[1]);
+ avio_close(pb[2]);
+ }else{
+ if(ff_guess_image2_codec(s->filename) == CODEC_ID_JPEG2000){
+ AVStream *st = s->streams[0];
+ if(st->codec->extradata_size > 8 &&
+ AV_RL32(st->codec->extradata+4) == MKTAG('j','p','2','h')){
+ if(pkt->size < 8 || AV_RL32(pkt->data+4) != MKTAG('j','p','2','c'))
+ goto error;
+ avio_wb32(pb[0], 12);
+ ffio_wfourcc(pb[0], "jP ");
+ avio_wb32(pb[0], 0x0D0A870A); // signature
+ avio_wb32(pb[0], 20);
+ ffio_wfourcc(pb[0], "ftyp");
+ ffio_wfourcc(pb[0], "jp2 ");
+ avio_wb32(pb[0], 0);
+ ffio_wfourcc(pb[0], "jp2 ");
+ avio_write(pb[0], st->codec->extradata, st->codec->extradata_size);
++ }else if(pkt->size >= 8 && AV_RB32(pkt->data) == 0xFF4FFF51){
++ //jpeg2000 codestream
+ }else if(pkt->size < 8 ||
+ (!st->codec->extradata_size &&
+ AV_RL32(pkt->data+4) != MKTAG('j','P',' ',' '))){ // signature
+ error:
- .extensions = "bmp,dpx,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png,"
- "ppm,sgi,tga,tif,tiff,jp2,xwd,sun,ras,rs,im1,im8,im24,"
++ av_log(s, AV_LOG_ERROR, "malformed JPEG 2000 codestream %X\n", AV_RB32(pkt->data));
+ return -1;
+ }
+ }
+ avio_write(pb[0], pkt->data, pkt->size);
+ }
+ avio_flush(pb[0]);
+ if (!img->is_pipe) {
+ avio_close(pb[0]);
+ }
+
+ img->img_number++;
+ return 0;
+ }
+
++#define OFFSET(x) offsetof(VideoMuxData, x)
++#define ENC AV_OPT_FLAG_ENCODING_PARAM
++static const AVOption muxoptions[] = {
++ { "updatefirst", "", OFFSET(updatefirst), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 1, ENC },
++ { NULL },
++};
++
++
+ #if CONFIG_IMAGE2_MUXER
++static const AVClass img2mux_class = {
++ .class_name = "image2 muxer",
++ .item_name = av_default_item_name,
++ .option = muxoptions,
++ .version = LIBAVUTIL_VERSION_INT,
++};
+ AVOutputFormat ff_image2_muxer = {
+ .name = "image2",
+ .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
- .flags = AVFMT_NOTIMESTAMPS | AVFMT_NODIMENSIONS | AVFMT_NOFILE
++ .extensions = "bmp,dpx,jls,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png,"
++ "ppm,sgi,tga,tif,tiff,jp2,j2c,xwd,sun,ras,rs,im1,im8,im24,"
+ "sunras",
+ .priv_data_size = sizeof(VideoMuxData),
+ .video_codec = CODEC_ID_MJPEG,
+ .write_header = write_header,
+ .write_packet = write_packet,
++ .flags = AVFMT_NOTIMESTAMPS | AVFMT_NODIMENSIONS | AVFMT_NOFILE,
++ .priv_class = &img2mux_class,
+ };
+ #endif
+ #if CONFIG_IMAGE2PIPE_MUXER
+ AVOutputFormat ff_image2pipe_muxer = {
+ .name = "image2pipe",
+ .long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
+ .priv_data_size = sizeof(VideoMuxData),
+ .video_codec = CODEC_ID_MJPEG,
+ .write_header = write_header,
+ .write_packet = write_packet,
+ .flags = AVFMT_NOTIMESTAMPS | AVFMT_NODIMENSIONS
+ };
+ #endif
unsigned trex_count;
int itunes_metadata; ///< metadata are itunes style
int chapter_track;
+ int use_absolute_path;
+ int64_t next_root_atom; ///< offset of the next root atom
} MOVContext;
int ff_mp4_read_descr_len(AVIOContext *pb);
sample = mov_find_next_sample(s, &st);
if (!sample) {
mov->found_mdat = 0;
- if (s->pb->seekable||
- mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
+ if (!mov->next_root_atom)
+ return AVERROR_EOF;
+ avio_seek(s->pb, mov->next_root_atom, SEEK_SET);
+ mov->next_root_atom = 0;
+ if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
- s->pb->eof_reached)
+ url_feof(s->pb))
return AVERROR_EOF;
av_dlog(s, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
goto retry;
} else
ffio_wfourcc(pb, "stco");
avio_wb32(pb, 0); /* version & flags */
- avio_wb32(pb, track->entry); /* entry count */
+ avio_wb32(pb, track->chunkCount); /* entry count */
for (i=0; i<track->entry; i++) {
+ if(!track->cluster[i].chunkNum)
+ continue;
if(mode64 == 1)
- avio_wb64(pb, track->cluster[i].pos);
+ avio_wb64(pb, track->cluster[i].pos + track->data_offset);
else
- avio_wb32(pb, track->cluster[i].pos);
+ avio_wb32(pb, track->cluster[i].pos + track->data_offset);
}
return update_size(pb, pos);
}
return 0;
}
+static void build_chunks(MOVTrack *trk)
+{
+ int i;
+ MOVIentry *chunk= &trk->cluster[0];
+ uint64_t chunkSize = chunk->size;
+ chunk->chunkNum= 1;
++ if (trk->chunkCount)
++ return;
+ trk->chunkCount= 1;
+ for(i=1; i<trk->entry; i++){
+ if(chunk->pos + chunkSize == trk->cluster[i].pos &&
+ chunkSize + trk->cluster[i].size < (1<<20)){
+ chunkSize += trk->cluster[i].size;
+ chunk->samples_in_chunk += trk->cluster[i].entries;
+ }else{
+ trk->cluster[i].chunkNum = chunk->chunkNum+1;
+ chunk=&trk->cluster[i];
+ chunkSize = chunk->size;
+ trk->chunkCount++;
+ }
+ }
+}
+
static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov,
AVFormatContext *s)
{
FF_MOV_FLAG_FRAG_CUSTOM)) &&
!mov->max_fragment_duration && !mov->max_fragment_size)
mov->max_fragment_duration = 5000000;
- mov->flags |= FF_MOV_FLAG_EMPTY_MOOV | FF_MOV_FLAG_SEPARATE_MOOF;
+ mov->flags |= FF_MOV_FLAG_EMPTY_MOOV | FF_MOV_FLAG_SEPARATE_MOOF |
+ FF_MOV_FLAG_FRAGMENT;
}
- /* Set the FRAGMENT flag if any of the fragmentation methods are
- * enabled. */
- if (mov->max_fragment_duration || mov->max_fragment_size ||
- mov->flags & (FF_MOV_FLAG_EMPTY_MOOV |
- FF_MOV_FLAG_FRAG_KEYFRAME |
- FF_MOV_FLAG_FRAG_CUSTOM))
- mov->flags |= FF_MOV_FLAG_FRAGMENT;
-
- if (!(mov->flags & FF_MOV_FLAG_EMPTY_MOOV))
+ if(mov->reserved_moov_size){
+ mov->reserved_moov_pos= avio_tell(pb);
+ avio_skip(pb, mov->reserved_moov_size);
+ }
+
+ if (!(mov->flags & FF_MOV_FLAG_FRAGMENT))
mov_write_mdat_tag(pb, mov);
if (t = av_dict_get(s->metadata, "creation_time", NULL, 0))
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+
#include <inttypes.h>
- #include "config.h"
+
#include "libavutil/bswap.h"
+ #include "config.h"
#include "rgb2rgb.h"
#include "swscale.h"
#include "swscale_internal.h"
void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
{
- const uint16_t *end;
- uint8_t *d = dst;
- const uint16_t *s = (const uint16_t *)src;
- end = s + src_size/2;
+ uint8_t *d = dst;
+ const uint16_t *s = (const uint16_t *)src;
+ const uint16_t *end = s + src_size / 2;
+
while (s < end) {
- register uint16_t bgr;
- bgr = *s++;
+ register uint16_t bgr = *s++;
#if HAVE_BIGENDIAN
*d++ = 255;
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
- *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
- *d++ = (bgr & 0x1F) << 3;
- *d++ = (bgr & 0x7E0) >> 3;
- *d++ = (bgr & 0xF800) >> 8;
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
++ *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
+ *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
#else
- *d++ = (bgr & 0xF800) >> 8;
- *d++ = (bgr & 0x7E0) >> 3;
- *d++ = (bgr & 0x1F) << 3;
+ *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
- *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
++ *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
*d++ = 255;
#endif
}
void rgb16to24(const uint8_t *src, uint8_t *dst, int src_size)
{
- const uint16_t *end;
- uint8_t *d = dst;
- const uint16_t *s = (const uint16_t *)src;
- end = s + src_size/2;
+ uint8_t *d = dst;
+ const uint16_t *s = (const uint16_t *)src;
+ const uint16_t *end = s + src_size / 2;
+
while (s < end) {
- register uint16_t bgr;
- bgr = *s++;
+ register uint16_t bgr = *s++;
- *d++ = (bgr & 0xF800) >> 8;
- *d++ = (bgr & 0x7E0) >> 3;
- *d++ = (bgr & 0x1F) << 3;
+ *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
- *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
++ *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
}
}
void rgb15tobgr32(const uint8_t *src, uint8_t *dst, int src_size)
{
- const uint16_t *end;
- uint8_t *d = dst;
- const uint16_t *s = (const uint16_t *)src;
- end = s + src_size/2;
+ uint8_t *d = dst;
+ const uint16_t *s = (const uint16_t *)src;
+ const uint16_t *end = s + src_size / 2;
+
while (s < end) {
- register uint16_t bgr;
- bgr = *s++;
+ register uint16_t bgr = *s++;
#if HAVE_BIGENDIAN
*d++ = 255;
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
- *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
- *d++ = (bgr & 0x1F) << 3;
- *d++ = (bgr & 0x3E0) >> 2;
- *d++ = (bgr & 0x7C00) >> 7;
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
++ *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
+ *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
#else
- *d++ = (bgr & 0x7C00) >> 7;
- *d++ = (bgr & 0x3E0) >> 2;
- *d++ = (bgr & 0x1F) << 3;
+ *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
- *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
++ *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
*d++ = 255;
#endif
}
void rgb15to24(const uint8_t *src, uint8_t *dst, int src_size)
{
- const uint16_t *end;
- uint8_t *d = dst;
- const uint16_t *s = (const uint16_t *)src;
- end = s + src_size/2;
+ uint8_t *d = dst;
+ const uint16_t *s = (const uint16_t *)src;
+ const uint16_t *end = s + src_size / 2;
+
while (s < end) {
- register uint16_t bgr;
- bgr = *s++;
+ register uint16_t bgr = *s++;
- *d++ = (bgr & 0x7C00) >> 7;
- *d++ = (bgr & 0x3E0) >> 2;
- *d++ = (bgr & 0x1F) << 3;
+ *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
- *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
++ *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
}
}
}
}
-void bgr8torgb8(const uint8_t *src, uint8_t *dst, int src_size)
-{
- int i, num_pixels = src_size;
-
- for (i = 0; i < num_pixels; i++) {
- register uint8_t rgb = src[i];
- unsigned r = (rgb & 0x07);
- unsigned g = (rgb & 0x38) >> 3;
- unsigned b = (rgb & 0xC0) >> 6;
- dst[i] = ((b << 1) & 0x07) | ((g & 0x07) << 3) | ((r & 0x03) << 6);
- }
-}
+
#define DEFINE_SHUFFLE_BYTES(a, b, c, d) \
- void shuffle_bytes_##a##b##c##d(const uint8_t *src, uint8_t *dst, int src_size) \
+ void shuffle_bytes_ ## a ## b ## c ## d(const uint8_t *src, \
+ uint8_t *dst, int src_size) \
{ \
- int i; \
+ int i; \
\
- for (i = 0; i < src_size; i+=4) { \
+ for (i = 0; i < src_size; i += 4) { \
dst[i + 0] = src[i + a]; \
dst[i + 1] = src[i + b]; \
dst[i + 2] = src[i + c]; \
}
}
- static inline void rgb15tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
-/*
- * I use less accurate approximation here by simply left-shifting the input
- * value and filling the low order bits with zeroes. This method improves PNG
- * compression but this scheme cannot reproduce white exactly, since it does
- * not generate an all-ones maximum value; the net effect is to darken the
- * image slightly.
- *
- * The better method should be "left bit replication":
- *
- * 4 3 2 1 0
- * ---------
- * 1 1 0 1 1
- *
- * 7 6 5 4 3 2 1 0
- * ----------------
- * 1 1 0 1 1 1 1 0
- * |=======| |===|
- * | leftmost bits repeated to fill open bits
- * |
- * original bits
- */
+ static inline void rgb15tobgr24_c(const uint8_t *src, uint8_t *dst,
+ int src_size)
{
- const uint16_t *end;
- uint8_t *d = dst;
- const uint16_t *s = (const uint16_t*)src;
- end = s + src_size/2;
+ uint8_t *d = dst;
+ const uint16_t *s = (const uint16_t *)src;
+ const uint16_t *end = s + src_size / 2;
+
while (s < end) {
- register uint16_t bgr;
- bgr = *s++;
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
- *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
+ register uint16_t bgr = *s++;
- *d++ = (bgr & 0x1F) << 3;
- *d++ = (bgr & 0x3E0) >> 2;
- *d++ = (bgr & 0x7C00) >> 7;
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
++ *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
+ *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
}
}
- static inline void rgb16tobgr24_c(const uint8_t *src, uint8_t *dst, int src_size)
+ static inline void rgb16tobgr24_c(const uint8_t *src, uint8_t *dst,
+ int src_size)
{
- const uint16_t *end;
- uint8_t *d = (uint8_t *)dst;
- const uint16_t *s = (const uint16_t *)src;
- end = s + src_size/2;
+ uint8_t *d = (uint8_t *)dst;
+ const uint16_t *s = (const uint16_t *)src;
+ const uint16_t *end = s + src_size / 2;
+
while (s < end) {
- register uint16_t bgr;
- bgr = *s++;
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
- *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
+ register uint16_t bgr = *s++;
- *d++ = (bgr & 0x1F) << 3;
- *d++ = (bgr & 0x7E0) >> 3;
- *d++ = (bgr & 0xF800) >> 8;
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
++ *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
+ *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
}
}
static inline void rgb15to32_c(const uint8_t *src, uint8_t *dst, int src_size)
{
- const uint16_t *end;
- uint8_t *d = dst;
- const uint16_t *s = (const uint16_t *)src;
- end = s + src_size/2;
+ uint8_t *d = dst;
+ const uint16_t *s = (const uint16_t *)src;
+ const uint16_t *end = s + src_size / 2;
+
while (s < end) {
- register uint16_t bgr;
- bgr = *s++;
+ register uint16_t bgr = *s++;
#if HAVE_BIGENDIAN
*d++ = 255;
- *d++ = (bgr & 0x7C00) >> 7;
- *d++ = (bgr & 0x3E0) >> 2;
- *d++ = (bgr & 0x1F) << 3;
+ *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
- *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
++ *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
#else
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
- *d++ = ((bgr&0x3E0)>>2) | ((bgr&0x3E0)>>7);
- *d++ = (bgr & 0x1F) << 3;
- *d++ = (bgr & 0x3E0) >> 2;
- *d++ = (bgr & 0x7C00) >> 7;
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
++ *d++ = ((bgr&0x03E0)>>2) | ((bgr&0x03E0)>> 7);
+ *d++ = ((bgr&0x7C00)>>7) | ((bgr&0x7C00)>>12);
*d++ = 255;
#endif
}
static inline void rgb16to32_c(const uint8_t *src, uint8_t *dst, int src_size)
{
- const uint16_t *end;
- uint8_t *d = dst;
- const uint16_t *s = (const uint16_t*)src;
- end = s + src_size/2;
+ uint8_t *d = dst;
+ const uint16_t *s = (const uint16_t *)src;
+ const uint16_t *end = s + src_size / 2;
+
while (s < end) {
- register uint16_t bgr;
- bgr = *s++;
+ register uint16_t bgr = *s++;
#if HAVE_BIGENDIAN
*d++ = 255;
- *d++ = (bgr & 0xF800) >> 8;
- *d++ = (bgr & 0x7E0) >> 3;
- *d++ = (bgr & 0x1F) << 3;
+ *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
- *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
++ *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
#else
- *d++ = ((bgr&0x1F)<<3) | ((bgr&0x1F)>>2);
- *d++ = ((bgr&0x7E0)>>3) | ((bgr&0x7E0)>>9);
- *d++ = (bgr & 0x1F) << 3;
- *d++ = (bgr & 0x7E0) >> 3;
- *d++ = (bgr & 0xF800) >> 8;
++ *d++ = ((bgr&0x001F)<<3) | ((bgr&0x001F)>> 2);
++ *d++ = ((bgr&0x07E0)>>3) | ((bgr&0x07E0)>> 9);
+ *d++ = ((bgr&0xF800)>>8) | ((bgr&0xF800)>>13);
*d++ = 255;
#endif
}
ydst += lumStride;
src += srcStride;
- if(y+1 == height)
++ if (y+1 == height)
+ break;
+
- for (i=0; i<chromWidth; i++) {
- unsigned int b = src[6*i+0];
- unsigned int g = src[6*i+1];
- unsigned int r = src[6*i+2];
+ for (i = 0; i < chromWidth; i++) {
+ unsigned int b = src[6 * i + 0];
+ unsigned int g = src[6 * i + 1];
+ unsigned int r = src[6 * i + 2];
- unsigned int Y = ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
+ unsigned int Y = ((RY * r + GY * g + BY * b) >> RGB2YUV_SHIFT) + 16;
- ydst[2*i] = Y;
+ ydst[2 * i] = Y;
- b = src[6*i+3];
- g = src[6*i+4];
- r = src[6*i+5];
+ b = src[6 * i + 3];
+ g = src[6 * i + 4];
+ r = src[6 * i + 5];
- Y = ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
- ydst[2*i+1] = Y;
+ Y = ((RY * r + GY * g + BY * b) >> RGB2YUV_SHIFT) + 16;
+ ydst[2 * i + 1] = Y;
}
udst += chromStride;
vdst += chromStride;
#include "rgb2rgb.h"
#include "swscale.h"
#include "swscale_internal.h"
- #include "libavutil/cpu.h"
- #include "libavutil/bswap.h"
+#include "libavutil/pixdesc.h"
extern const uint8_t dither_4x4_16[4][8];
extern const uint8_t dither_8x8_32[8][8];
#define LOADCHROMA(i) \
U = pu[i]; \
V = pv[i]; \
- r = (void *)c->table_rV[V]; \
- g = (void *)(c->table_gU[U] + c->table_gV[V]); \
- b = (void *)c->table_bU[U];
+ r = (void *)c->table_rV[V+YUVRGB_TABLE_HEADROOM]; \
+ g = (void *)(c->table_gU[U+YUVRGB_TABLE_HEADROOM] + c->table_gV[V+YUVRGB_TABLE_HEADROOM]); \
+ b = (void *)c->table_bU[U+YUVRGB_TABLE_HEADROOM];
- #define PUTRGB(dst,src,i) \
- Y = src[2*i]; \
- dst[2*i ] = r[Y] + g[Y] + b[Y]; \
- Y = src[2*i+1]; \
- dst[2*i+1] = r[Y] + g[Y] + b[Y];
-
- #define PUTRGB24(dst,src,i) \
- Y = src[2*i]; \
- dst[6*i+0] = r[Y]; dst[6*i+1] = g[Y]; dst[6*i+2] = b[Y]; \
- Y = src[2*i+1]; \
- dst[6*i+3] = r[Y]; dst[6*i+4] = g[Y]; dst[6*i+5] = b[Y];
-
- #define PUTBGR24(dst,src,i) \
- Y = src[2*i]; \
- dst[6*i+0] = b[Y]; dst[6*i+1] = g[Y]; dst[6*i+2] = r[Y]; \
- Y = src[2*i+1]; \
- dst[6*i+3] = b[Y]; dst[6*i+4] = g[Y]; dst[6*i+5] = r[Y];
-
- #define PUTRGBA(dst,ysrc,asrc,i,s) \
- Y = ysrc[2*i]; \
- dst[2*i ] = r[Y] + g[Y] + b[Y] + (asrc[2*i ]<<s); \
- Y = ysrc[2*i+1]; \
- dst[2*i+1] = r[Y] + g[Y] + b[Y] + (asrc[2*i+1]<<s);
-
- #define PUTRGB48(dst,src,i) \
- Y = src[2*i]; \
- dst[12*i+ 0] = dst[12*i+ 1] = r[Y]; \
- dst[12*i+ 2] = dst[12*i+ 3] = g[Y]; \
- dst[12*i+ 4] = dst[12*i+ 5] = b[Y]; \
- Y = src[2*i+1]; \
- dst[12*i+ 6] = dst[12*i+ 7] = r[Y]; \
- dst[12*i+ 8] = dst[12*i+ 9] = g[Y]; \
- dst[12*i+10] = dst[12*i+11] = b[Y];
-
- #define PUTBGR48(dst,src,i) \
- Y = src[2*i]; \
- dst[12*i+ 0] = dst[12*i+ 1] = b[Y]; \
- dst[12*i+ 2] = dst[12*i+ 3] = g[Y]; \
- dst[12*i+ 4] = dst[12*i+ 5] = r[Y]; \
- Y = src[2*i+1]; \
- dst[12*i+ 6] = dst[12*i+ 7] = b[Y]; \
- dst[12*i+ 8] = dst[12*i+ 9] = g[Y]; \
- dst[12*i+10] = dst[12*i+11] = r[Y];
-
- #define YUV2RGBFUNC(func_name, dst_type, alpha) \
- static int func_name(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY, \
- int srcSliceH, uint8_t* dst[], int dstStride[]) \
- {\
- int y;\
- \
- if (!alpha && c->srcFormat == PIX_FMT_YUV422P) {\
- srcStride[1] *= 2;\
- srcStride[2] *= 2;\
- }\
- for (y=0; y<srcSliceH; y+=2) {\
- dst_type *dst_1 = (dst_type*)(dst[0] + (y+srcSliceY )*dstStride[0]);\
- dst_type *dst_2 = (dst_type*)(dst[0] + (y+srcSliceY+1)*dstStride[0]);\
- dst_type av_unused *r, *b;\
- dst_type *g;\
- const uint8_t *py_1 = src[0] + y*srcStride[0];\
- const uint8_t *py_2 = py_1 + srcStride[0];\
- const uint8_t *pu = src[1] + (y>>1)*srcStride[1];\
- const uint8_t *pv = src[2] + (y>>1)*srcStride[2];\
- const uint8_t av_unused *pa_1, *pa_2;\
- unsigned int h_size = c->dstW>>3;\
- if (alpha) {\
- pa_1 = src[3] + y*srcStride[3];\
- pa_2 = pa_1 + srcStride[3];\
- }\
- while (h_size--) {\
- int av_unused U, V;\
- int Y;\
-
- #define ENDYUV2RGBLINE(dst_delta)\
- pu += 4;\
- pv += 4;\
- py_1 += 8;\
- py_2 += 8;\
- dst_1 += dst_delta;\
- dst_2 += dst_delta;\
- }\
- if (c->dstW & 4) {\
- int av_unused Y, U, V;\
-
- #define ENDYUV2RGBFUNC()\
- }\
- }\
- return srcSliceH;\
- }
+ #define PUTRGB(dst, src, i) \
+ Y = src[2 * i]; \
+ dst[2 * i] = r[Y] + g[Y] + b[Y]; \
+ Y = src[2 * i + 1]; \
+ dst[2 * i + 1] = r[Y] + g[Y] + b[Y];
+
+ #define PUTRGB24(dst, src, i) \
+ Y = src[2 * i]; \
+ dst[6 * i + 0] = r[Y]; \
+ dst[6 * i + 1] = g[Y]; \
+ dst[6 * i + 2] = b[Y]; \
+ Y = src[2 * i + 1]; \
+ dst[6 * i + 3] = r[Y]; \
+ dst[6 * i + 4] = g[Y]; \
+ dst[6 * i + 5] = b[Y];
+
+ #define PUTBGR24(dst, src, i) \
+ Y = src[2 * i]; \
+ dst[6 * i + 0] = b[Y]; \
+ dst[6 * i + 1] = g[Y]; \
+ dst[6 * i + 2] = r[Y]; \
+ Y = src[2 * i + 1]; \
+ dst[6 * i + 3] = b[Y]; \
+ dst[6 * i + 4] = g[Y]; \
+ dst[6 * i + 5] = r[Y];
+
+ #define PUTRGBA(dst, ysrc, asrc, i, s) \
+ Y = ysrc[2 * i]; \
+ dst[2 * i] = r[Y] + g[Y] + b[Y] + (asrc[2 * i] << s); \
+ Y = ysrc[2 * i + 1]; \
+ dst[2 * i + 1] = r[Y] + g[Y] + b[Y] + (asrc[2 * i + 1] << s);
+
+ #define PUTRGB48(dst, src, i) \
+ Y = src[ 2 * i]; \
+ dst[12 * i + 0] = dst[12 * i + 1] = r[Y]; \
+ dst[12 * i + 2] = dst[12 * i + 3] = g[Y]; \
+ dst[12 * i + 4] = dst[12 * i + 5] = b[Y]; \
+ Y = src[ 2 * i + 1]; \
+ dst[12 * i + 6] = dst[12 * i + 7] = r[Y]; \
+ dst[12 * i + 8] = dst[12 * i + 9] = g[Y]; \
+ dst[12 * i + 10] = dst[12 * i + 11] = b[Y];
+
+ #define PUTBGR48(dst, src, i) \
+ Y = src[2 * i]; \
+ dst[12 * i + 0] = dst[12 * i + 1] = b[Y]; \
+ dst[12 * i + 2] = dst[12 * i + 3] = g[Y]; \
+ dst[12 * i + 4] = dst[12 * i + 5] = r[Y]; \
+ Y = src[2 * i + 1]; \
+ dst[12 * i + 6] = dst[12 * i + 7] = b[Y]; \
+ dst[12 * i + 8] = dst[12 * i + 9] = g[Y]; \
+ dst[12 * i + 10] = dst[12 * i + 11] = r[Y];
+
+ #define YUV2RGBFUNC(func_name, dst_type, alpha) \
+ static int func_name(SwsContext *c, const uint8_t *src[], \
+ int srcStride[], int srcSliceY, int srcSliceH, \
+ uint8_t *dst[], int dstStride[]) \
+ { \
+ int y; \
+ \
+ if (!alpha && c->srcFormat == PIX_FMT_YUV422P) { \
+ srcStride[1] *= 2; \
+ srcStride[2] *= 2; \
+ } \
+ for (y = 0; y < srcSliceH; y += 2) { \
+ dst_type *dst_1 = \
+ (dst_type *)(dst[0] + (y + srcSliceY) * dstStride[0]); \
+ dst_type *dst_2 = \
+ (dst_type *)(dst[0] + (y + srcSliceY + 1) * dstStride[0]); \
+ dst_type av_unused *r, *g, *b; \
+ const uint8_t *py_1 = src[0] + y * srcStride[0]; \
+ const uint8_t *py_2 = py_1 + srcStride[0]; \
+ const uint8_t *pu = src[1] + (y >> 1) * srcStride[1]; \
+ const uint8_t *pv = src[2] + (y >> 1) * srcStride[2]; \
+ const uint8_t av_unused *pa_1, *pa_2; \
+ unsigned int h_size = c->dstW >> 3; \
+ if (alpha) { \
+ pa_1 = src[3] + y * srcStride[3]; \
+ pa_2 = pa_1 + srcStride[3]; \
+ } \
+ while (h_size--) { \
+ int av_unused U, V, Y; \
+
+ #define ENDYUV2RGBLINE(dst_delta) \
+ pu += 4; \
+ pv += 4; \
+ py_1 += 8; \
+ py_2 += 8; \
+ dst_1 += dst_delta; \
+ dst_2 += dst_delta; \
+ } \
+ if (c->dstW & 4) { \
+ int av_unused Y, U, V; \
+
+ #define ENDYUV2RGBFUNC() \
+ } \
+ } \
+ return srcSliceH; \
+ }
- #define CLOSEYUV2RGBFUNC(dst_delta)\
- ENDYUV2RGBLINE(dst_delta)\
+ #define CLOSEYUV2RGBFUNC(dst_delta) \
+ ENDYUV2RGBLINE(dst_delta) \
ENDYUV2RGBFUNC()
YUV2RGBFUNC(yuv2rgb_c_48, uint8_t, 0)
CLOSEYUV2RGBFUNC(8)
YUV2RGBFUNC(yuv2rgb_c_1_ordered_dither, uint8_t, 0)
- const uint8_t *d128 = dither_8x8_220[y&7];
- char out_1 = 0, out_2 = 0;
- g= c->table_gU[128 + YUVRGB_TABLE_HEADROOM] + c->table_gV[128 + YUVRGB_TABLE_HEADROOM];
+ const uint8_t *d128 = dither_8x8_220[y & 7];
+ char out_1 = 0, out_2 = 0;
- g = c->table_gU[128] + c->table_gV[128];
++ g = c->table_gU[128 + YUVRGB_TABLE_HEADROOM] + c->table_gV[128 + YUVRGB_TABLE_HEADROOM];
- #define PUTRGB1(out,src,i,o) \
- Y = src[2*i]; \
- out+= out + g[Y+d128[0+o]]; \
- Y = src[2*i+1]; \
- out+= out + g[Y+d128[1+o]];
+ #define PUTRGB1(out, src, i, o) \
+ Y = src[2 * i]; \
+ out += out + g[Y + d128[0 + o]]; \
+ Y = src[2 * i + 1]; \
+ out += out + g[Y + d128[1 + o]];
- PUTRGB1(out_1,py_1,0,0);
- PUTRGB1(out_2,py_2,0,0+8);
+ PUTRGB1(out_1, py_1, 0, 0);
+ PUTRGB1(out_2, py_2, 0, 0 + 8);
- PUTRGB1(out_2,py_2,1,2+8);
- PUTRGB1(out_1,py_1,1,2);
+ PUTRGB1(out_2, py_2, 1, 2 + 8);
+ PUTRGB1(out_1, py_1, 1, 2);
- PUTRGB1(out_1,py_1,2,4);
- PUTRGB1(out_2,py_2,2,4+8);
+ PUTRGB1(out_1, py_1, 2, 4);
+ PUTRGB1(out_2, py_2, 2, 4 + 8);
- PUTRGB1(out_2,py_2,3,6+8);
- PUTRGB1(out_1,py_1,3,6);
+ PUTRGB1(out_2, py_2, 3, 6 + 8);
+ PUTRGB1(out_1, py_1, 3, 6);
- dst_1[0]= out_1;
- dst_2[0]= out_2;
+ dst_1[0] = out_1;
+ dst_2[0] = out_2;
CLOSEYUV2RGBFUNC(1)
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
if (t)
return t;
- av_log(c, AV_LOG_WARNING, "No accelerated colorspace conversion found from %s to %s.\n",
+ av_log(c, AV_LOG_WARNING,
+ "No accelerated colorspace conversion found from %s to %s.\n",
- sws_format_name(c->srcFormat), sws_format_name(c->dstFormat));
+ av_get_pix_fmt_name(c->srcFormat), av_get_pix_fmt_name(c->dstFormat));
switch (c->dstFormat) {
case PIX_FMT_BGR48BE:
- case PIX_FMT_BGR48LE: return yuv2rgb_c_bgr48;
+ case PIX_FMT_BGR48LE:
+ return yuv2rgb_c_bgr48;
case PIX_FMT_RGB48BE:
- case PIX_FMT_RGB48LE: return yuv2rgb_c_48;
+ case PIX_FMT_RGB48LE:
+ return yuv2rgb_c_48;
case PIX_FMT_ARGB:
- case PIX_FMT_ABGR: if (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat)) return yuva2argb_c;
+ case PIX_FMT_ABGR:
- if (CONFIG_SWSCALE_ALPHA && c->srcFormat == PIX_FMT_YUVA420P)
++ if (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat))
+ return yuva2argb_c;
case PIX_FMT_RGBA:
- case PIX_FMT_BGRA: return (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat)) ? yuva2rgba_c : yuv2rgb_c_32;
- case PIX_FMT_RGB24: return yuv2rgb_c_24_rgb;
- case PIX_FMT_BGR24: return yuv2rgb_c_24_bgr;
+ case PIX_FMT_BGRA:
- if (CONFIG_SWSCALE_ALPHA && c->srcFormat == PIX_FMT_YUVA420P)
- return yuva2rgba_c;
- else
- return yuv2rgb_c_32;
++ return (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat)) ? yuva2rgba_c : yuv2rgb_c_32;
+ case PIX_FMT_RGB24:
+ return yuv2rgb_c_24_rgb;
+ case PIX_FMT_BGR24:
+ return yuv2rgb_c_24_bgr;
case PIX_FMT_RGB565:
case PIX_FMT_BGR565:
case PIX_FMT_RGB555:
return NULL;
}
- static void fill_table(uint8_t* table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize, const int inc, void *y_tab)
-static void fill_table(uint8_t *table[256], const int elemsize,
++static void fill_table(uint8_t* table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize,
+ const int inc, void *y_tab)
{
int i;
- int64_t cb = 0;
uint8_t *y_table = y_tab;
y_table -= elemsize * (inc >> 9);
}
}
-static void fill_gv_table(int table[256], const int elemsize, const int inc)
+static void fill_gv_table(int table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize, const int inc)
{
int i;
- int off = -(inc >> 9);
- int64_t cb = 0;
+ int off = -(inc >> 9);
- for (i = 0; i < 256; i++) {
+ for (i = 0; i < 256 + 2*YUVRGB_TABLE_HEADROOM; i++) {
+ int64_t cb = av_clip(i-YUVRGB_TABLE_HEADROOM, 0, 255)*inc;
table[i] = elemsize * (off + (cb >> 16));
- cb += inc;
}
}
OSDN Git Service
