Attachment #907292 for bug #917591

View | Details | Raw Unified | Return to bug 917591 | Differences between

and this patch

Lines 27-32 Link Here

(-)a/libavformat/dump.c (+15 lines)
27	#include "libavutil/intreadwrite.h"	27	#include "libavutil/intreadwrite.h"
28	#include "libavutil/log.h"	28	#include "libavutil/log.h"
29	#include "libavutil/mastering_display_metadata.h"	29	#include "libavutil/mastering_display_metadata.h"
		30	#include "libavutil/ambient_viewing_environment.h"
30	#include "libavutil/dovi_meta.h"	31	#include "libavutil/dovi_meta.h"
31	#include "libavutil/mathematics.h"	32	#include "libavutil/mathematics.h"
32	#include "libavutil/opt.h"	33	#include "libavutil/opt.h"
Lines 366-371 static void dump_content_light_metadata(void ctx, const AVPacketSideData sd) Link Here
366	metadata->MaxCLL, metadata->MaxFALL);	367	metadata->MaxCLL, metadata->MaxFALL);
367	}	368	}
368		369
		370	static void dump_ambient_viewing_environment_metadata(void ctx, const AVPacketSideData sd)
		371	{
		372	const AVAmbientViewingEnvironment *ambient =
		373	(const AVAmbientViewingEnvironment *)sd->data;
		374	av_log(ctx, AV_LOG_INFO, "Ambient Viewing Environment, "
		375	"ambient_illuminance=%f, ambient_light_x=%f, ambient_light_y=%f",
		376	av_q2d(ambient->ambient_illuminance),
		377	av_q2d(ambient->ambient_light_x),
		378	av_q2d(ambient->ambient_light_y));
		379	}
		380
369	static void dump_spherical(void ctx, const AVCodecParameters par,	381	static void dump_spherical(void ctx, const AVCodecParameters par,
370	const AVPacketSideData *sd)	382	const AVPacketSideData *sd)
371	{	383	{
Lines 497-502 static void dump_sidedata(void ctx, const AVStream st, const char *indent) Link Here
497	av_log(ctx, AV_LOG_INFO, "SMPTE ST 12-1:2014: ");	509	av_log(ctx, AV_LOG_INFO, "SMPTE ST 12-1:2014: ");
498	dump_s12m_timecode(ctx, st, sd);	510	dump_s12m_timecode(ctx, st, sd);
499	break;	511	break;
		512	case AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT:
		513	dump_ambient_viewing_environment_metadata(ctx, sd);
		514	break;
500	default:	515	default:
501	av_log(ctx, AV_LOG_INFO, "unknown side data type %d "	516	av_log(ctx, AV_LOG_INFO, "unknown side data type %d "
502	"(%"SIZE_SPECIFIER" bytes)", sd->type, sd->size);	517	"(%"SIZE_SPECIFIER" bytes)", sd->type, sd->size);

Lines 29-34 Link Here

(-)a/libavformat/isom.h (+3 lines)
29		29
30	#include "libavutil/encryption_info.h"	30	#include "libavutil/encryption_info.h"
31	#include "libavutil/mastering_display_metadata.h"	31	#include "libavutil/mastering_display_metadata.h"
		32	#include "libavutil/ambient_viewing_environment.h"
32	#include "libavutil/spherical.h"	33	#include "libavutil/spherical.h"
33	#include "libavutil/stereo3d.h"	34	#include "libavutil/stereo3d.h"
34		35
Lines 249-254 typedef struct MOVStreamContext { Link Here
249	AVMasteringDisplayMetadata *mastering;	250	AVMasteringDisplayMetadata *mastering;
250	AVContentLightMetadata *coll;	251	AVContentLightMetadata *coll;
251	size_t coll_size;	252	size_t coll_size;
		253	AVAmbientViewingEnvironment *ambient;
		254	size_t ambient_size;
252		255
253	uint32_t format;	256	uint32_t format;
254		257




    return 0;
}

static int mov_read_amve(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
    MOVStreamContext *sc;
    const int illuminance_den = 10000;
    const int ambient_den = 50000;
    if (c->fc->nb_streams < 1)
        return AVERROR_INVALIDDATA;
    sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
    if (atom.size < 6) {
        av_log(c->fc, AV_LOG_ERROR, "Empty Ambient Viewing Environment Info box\n");
        return AVERROR_INVALIDDATA;
    }
    if (sc->ambient){
        av_log(c->fc, AV_LOG_WARNING, "Ignoring duplicate AMVE\n");
        return 0;
    }
    sc->ambient = av_ambient_viewing_environment_alloc(&sc->ambient_size);
    if (!sc->ambient)
        return AVERROR(ENOMEM);
    sc->ambient->ambient_illuminance  = av_make_q(avio_rb32(pb), illuminance_den);
    sc->ambient->ambient_light_x = av_make_q(avio_rb16(pb), ambient_den);
    sc->ambient->ambient_light_y = av_make_q(avio_rb16(pb), ambient_den);
    return 0;
}

static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
    AVStream *st;

{ MKTAG('p','c','m','C'), mov_read_pcmc }, /* PCM configuration box */
{ MKTAG('p','i','t','m'), mov_read_pitm },
{ MKTAG('e','v','c','C'), mov_read_glbl },
{ MKTAG('a','m','v','e'), mov_read_amve }, /* ambient viewing environment box */
{ 0, NULL }
};


        av_freep(&sc->spherical);
        av_freep(&sc->mastering);
        av_freep(&sc->coll);
        av_freep(&sc->ambient);
    }

    av_freep(&mov->dv_demux);


                sc->coll = NULL;
            }
            if (sc->ambient) {
                if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
                                             AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,
                                             (uint8_t *)sc->ambient, sc->ambient_size, 0))
                    return AVERROR(ENOMEM);

                sc->ambient = NULL;
            }
            break;
        }
    }




    return 32;
}

static int mov_write_amve_tag(AVIOContext *pb, MOVTrack *track)
{
    const int illuminance_den = 10000;
    const int ambient_den = 50000;
    const AVPacketSideData *side_data;
    const AVAmbientViewingEnvironment *ambient = NULL;

    side_data = av_packet_side_data_get(track->st->codecpar->coded_side_data,
                                        track->st->codecpar->nb_coded_side_data,
                                        AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT);

    if (side_data)
        ambient = (const AVAmbientViewingEnvironment*)side_data->data;
    if (!ambient || !ambient->ambient_illuminance.num) {
        return 0;
    }

    avio_wb32(pb, 16); // size
    ffio_wfourcc(pb, "amve");
    avio_wb32(pb, rescale_mdcv(ambient->ambient_illuminance, illuminance_den));
    avio_wb16(pb, rescale_mdcv(ambient->ambient_light_x, ambient_den));
    avio_wb16(pb, rescale_mdcv(ambient->ambient_light_y, ambient_den));
    return 16;
}

static void find_compressor(char * compressor_name, int len, MOVTrack *track)
{
    AVDictionaryEntry *encoder;

    if (track->mode == MODE_MOV || track->mode == MODE_MP4) {
        mov_write_clli_tag(pb, track);
        mov_write_mdcv_tag(pb, track);
        mov_write_amve_tag(pb, track);
    }

    if (track->mode == MODE_MP4 && mov->fc->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
- 

Return to bug 917591

Lines 6046-6051 static int mov_read_clli(MOVContext c, AVIOContext pb, MOVAtom atom) Link Here

(-)a/libavformat/mov.c (+35 lines)
6046	return 0;	6046	return 0;
6047	}	6047	}
6048		6048
		6049	static int mov_read_amve(MOVContext c, AVIOContext pb, MOVAtom atom)
		6050	{
		6051	MOVStreamContext *sc;
		6052	const int illuminance_den = 10000;
		6053	const int ambient_den = 50000;
		6054	if (c->fc->nb_streams < 1)
		6055	return AVERROR_INVALIDDATA;
		6056	sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
		6057	if (atom.size < 6) {
		6058	av_log(c->fc, AV_LOG_ERROR, "Empty Ambient Viewing Environment Info box\n");
		6059	return AVERROR_INVALIDDATA;
		6060	}
		6061	if (sc->ambient){
		6062	av_log(c->fc, AV_LOG_WARNING, "Ignoring duplicate AMVE\n");
		6063	return 0;
		6064	}
		6065	sc->ambient = av_ambient_viewing_environment_alloc(&sc->ambient_size);
		6066	if (!sc->ambient)
		6067	return AVERROR(ENOMEM);
		6068	sc->ambient->ambient_illuminance = av_make_q(avio_rb32(pb), illuminance_den);
		6069	sc->ambient->ambient_light_x = av_make_q(avio_rb16(pb), ambient_den);
		6070	sc->ambient->ambient_light_y = av_make_q(avio_rb16(pb), ambient_den);
		6071	return 0;
		6072	}
		6073
6049	static int mov_read_st3d(MOVContext c, AVIOContext pb, MOVAtom atom)	6074	static int mov_read_st3d(MOVContext c, AVIOContext pb, MOVAtom atom)
6050	{	6075	{
6051	AVStream *st;	6076	AVStream *st;
Lines 7966-7971 static const MOVParseTableEntry mov_default_parse_table[] = { Link Here
7966	{ MKTAG('p','c','m','C'), mov_read_pcmc }, /* PCM configuration box */	7991	{ MKTAG('p','c','m','C'), mov_read_pcmc }, /* PCM configuration box */
7967	{ MKTAG('p','i','t','m'), mov_read_pitm },	7992	{ MKTAG('p','i','t','m'), mov_read_pitm },
7968	{ MKTAG('e','v','c','C'), mov_read_glbl },	7993	{ MKTAG('e','v','c','C'), mov_read_glbl },
		7994	{ MKTAG('a','m','v','e'), mov_read_amve }, /* ambient viewing environment box */
7969	{ 0, NULL }	7995	{ 0, NULL }
7970	};	7996	};
7971		7997
Lines 8436-8441 static int mov_read_close(AVFormatContext *s) Link Here
8436	av_freep(&sc->spherical);	8462	av_freep(&sc->spherical);
8437	av_freep(&sc->mastering);	8463	av_freep(&sc->mastering);
8438	av_freep(&sc->coll);	8464	av_freep(&sc->coll);
		8465	av_freep(&sc->ambient);
8439	}	8466	}
8440		8467
8441	av_freep(&mov->dv_demux);	8468	av_freep(&mov->dv_demux);
Lines 8797-8802 static int mov_read_header(AVFormatContext *s) Link Here
8797		8824
8798	sc->coll = NULL;	8825	sc->coll = NULL;
8799	}	8826	}
		8827	if (sc->ambient) {
		8828	if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
		8829	AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,
		8830	(uint8_t *)sc->ambient, sc->ambient_size, 0))
		8831	return AVERROR(ENOMEM);
		8832
		8833	sc->ambient = NULL;
		8834	}
8800	break;	8835	break;
8801	}	8836	}
8802	}	8837	}

Lines 2226-2231 static int mov_write_mdcv_tag(AVIOContext pb, MOVTrack track) Link Here

(-)a/libavformat/movenc.c (-1 / +26 lines)
2226	return 32;	2226	return 32;
2227	}	2227	}
2228		2228
		2229	static int mov_write_amve_tag(AVIOContext pb, MOVTrack track)
		2230	{
		2231	const int illuminance_den = 10000;
		2232	const int ambient_den = 50000;
		2233	const AVPacketSideData *side_data;
		2234	const AVAmbientViewingEnvironment *ambient = NULL;
		2235
		2236	side_data = av_packet_side_data_get(track->st->codecpar->coded_side_data,
		2237	track->st->codecpar->nb_coded_side_data,
		2238	AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT);
		2239
		2240	if (side_data)
		2241	ambient = (const AVAmbientViewingEnvironment*)side_data->data;
		2242	if (!ambient \|\| !ambient->ambient_illuminance.num) {
		2243	return 0;
		2244	}
		2245
		2246	avio_wb32(pb, 16); // size
		2247	ffio_wfourcc(pb, "amve");
		2248	avio_wb32(pb, rescale_mdcv(ambient->ambient_illuminance, illuminance_den));
		2249	avio_wb16(pb, rescale_mdcv(ambient->ambient_light_x, ambient_den));
		2250	avio_wb16(pb, rescale_mdcv(ambient->ambient_light_y, ambient_den));
		2251	return 16;
		2252	}
		2253
2229	static void find_compressor(char * compressor_name, int len, MOVTrack *track)	2254	static void find_compressor(char * compressor_name, int len, MOVTrack *track)
2230	{	2255	{
2231	AVDictionaryEntry *encoder;	2256	AVDictionaryEntry *encoder;
Lines 2437-2442 static int mov_write_video_tag(AVFormatContext s, AVIOContext pb, MOVMuxContex Link Here
2437	if (track->mode == MODE_MOV \|\| track->mode == MODE_MP4) {	2462	if (track->mode == MODE_MOV \|\| track->mode == MODE_MP4) {
2438	mov_write_clli_tag(pb, track);	2463	mov_write_clli_tag(pb, track);
2439	mov_write_mdcv_tag(pb, track);	2464	mov_write_mdcv_tag(pb, track);
		2465	mov_write_amve_tag(pb, track);
2440	}	2466	}
2441		2467
2442	if (track->mode == MODE_MP4 && mov->fc->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {	2468	if (track->mode == MODE_MP4 && mov->fc->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
2443	-