{"id":367,"date":"2011-02-14T18:59:00","date_gmt":"2011-02-14T18:59:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/xuggler-tutorial-transcoding-and-media-modification.html"},"modified":"2012-10-21T19:36:29","modified_gmt":"2012-10-21T19:36:29","slug":"xuggler-tutorial-transcoding-media","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/02\/xuggler-tutorial-transcoding-media.html","title":{"rendered":"Xuggler Tutorial: Transcoding and Media Modification"},"content":{"rendered":"
Note:<\/strong> This is part of our \u201cXuggler Development Tutorials<\/a>\u201d series.<\/i><\/p>\n

In my previous tutorial, I performed a short Introduction to Xuggler for Video Manipulation<\/a>. In this part, we are going to see some more exciting capabilities provided by Xuggler<\/a> and FFmpeg<\/a>, like video transcoding and media modification. Don’t forget that Xuggler<\/a> is a Java library that can be used to uncompress, manipulate, and compress recorded or live video in real time. <\/p>\n

Xuggler offers two distinct programming APIs which can be used for the same purpose. First, we have the MediaTool API<\/a>:<\/p>\n

MediaTool is a simple Application Programming Interface (API) for decoding, encoding and modifying video in Java. MediaTool hides many of the nitty-gritty details of containers, codecs, and others so you can focus on the media, and not the tools. That said, MediaTool still provides access to the underlying Xuggler objects, so you have fine grain control if you need it.<\/span><\/p>\n

And then there is the Xuggler Advanced API<\/a>, which allows you to delve into the details of video manipulation, but adds a layer of complexity.<\/p>\n

To begin, we will use the MediaTool API<\/a> and in subsequent tutorials we will also deal with the Advanced API too.<\/p>\n

Let’s start by transcoding media<\/a> from one format to another. Transcoding<\/a> is the direct digital-to-digital conversion of one encoding<\/a> to another. This is usually done in cases where a target device does not support the format or has limited storage capacity that mandates a reduced file size, or to convert incompatible or obsolete data to a better-supported or modern format. Transcoding is commonly a lossy process<\/a>, where “lossy” compression is a data encoding method which discards (loses) some of the data, in order to achieve its goal, with the result that decompressing the data yields content that is different from the original, though similar enough to be useful in some way.<\/p>\n

Let’s see some high level code for transcoding and I will explain the details later.<\/p>\n

package com.javacodegeeks.xuggler;\r\n\r\nimport com.xuggle.mediatool.IMediaReader;\r\nimport com.xuggle.mediatool.IMediaViewer;\r\nimport com.xuggle.mediatool.IMediaWriter;\r\nimport com.xuggle.mediatool.ToolFactory;\r\n\r\npublic class TranscodingExample {\r\n\r\n    private static final String inputFilename = \"c:\/myvideo.mp4\";\r\n    private static final String outputFilename = \"c:\/myvideo.flv\";\r\n\r\n    public static void main(String[] args) {\r\n\r\n        \/\/ create a media reader\r\n        IMediaReader mediaReader = \r\n               ToolFactory.makeReader(inputFilename);\r\n        \r\n        \/\/ create a media writer\r\n        IMediaWriter mediaWriter = \r\n               ToolFactory.makeWriter(outputFilename, mediaReader);\r\n\r\n        \/\/ add a writer to the reader, to create the output file\r\n        mediaReader.addListener(mediaWriter);\r\n        \r\n        \/\/ create a media viewer with stats enabled\r\n        IMediaViewer mediaViewer = ToolFactory.makeViewer(true);\r\n        \r\n        \/\/ add a viewer to the reader, to see the decoded media\r\n        mediaReader.addListener(mediaViewer);\r\n\r\n        \/\/ read and decode packets from the source file and\r\n        \/\/ and dispatch decoded audio and video to the writer\r\n        while (mediaReader.readPacket() == null) ;\r\n\r\n    }\r\n\r\n}\r\n<\/pre>\n
With a few lines of code, we are able to convert an MPEG-4<\/a> input file to a FLV<\/a> one. We start by creating an IMediaReader<\/a> which is used to read and decode media. It opens up a media container, reads packets from it, decodes the data, and then dispatches information about the data to any registered IMediaListener<\/a> objects. This is where the IMediaWriter<\/a> class comes into play. It encodes and decodes media, handling both audio and video streams. To make things more interesting, we also attach an IMediaViewer<\/a> to our reader. This is used as a debuging tool, allowing us to view the video while it is being decoded. Additionally, we are presented with various stats during the process. Note that this class is in experimental mode, meaning it has some bugs where it can hang, so handle with care.<\/p>\n
Essentially, with the above code, we attach our two listeners, the IMediaWriter<\/a> and the IMediaViewer<\/a>, to our IMediaReader<\/a> object and we handle the callbacks while the reader reads and decodes packets from the source file. This is performed in the \u201cwhile\u201d loop. If we run the application with a sample input file, we will be presented with a screen similar to this:<\/p>\n
\"\"<\/a>
 
<\/div> <\/div><\/p>\n
\"\"<\/a><\/p>\n
After the process is completed (it will last as long as the source video file since we are simultaneously viewing it in real time), a new output file will have been created in FLV format.<\/p>\n
Let’s use Ffmpeg from command line in order to compare the input and output files:<\/p>\n
ffmpeg.exe -i c:\/myvideo.mp4
\nSeems stream 1 codec frame rate differs from container frame rate: 59.92 (14981\/250) -> 29.96 (14981\/500)
\nInput #0, mov,mp4,m4a,3gp,3g2,mj2, from ‘c:\/myvideo.mp4’:
\nMetadata:
\nmajor_brand     : mp42
\nminor_version   : 0
\ncompatible_brands: isomavc1mp42
\nDuration: 00:04:20.96, start: 0.000000, bitrate: 582 kb\/s
\nStream #0.0(und): Audio: aac, 44100 Hz, stereo, s16, 115 kb\/s
\nStream #0.1(und): Video: h264, yuv420p, 480×270 [PAR 1:1 DAR 16:9], 464 kb\/s, 29.96 fps, 29.96 tbr, 29962 tbn, 59.92 tbc<\/span><\/p>\n
In the original video file, the container is MPEG-4<\/a> and there are two streams: an audio stream using AAC<\/a> at 44100Hz and a video stream using H.264<\/a>.<\/p>\n
ffmpeg.exe -i c:\/myvideo.flv
\nSeems stream 0 codec frame rate differs from container frame rate: 1000.00 (1000\/1) -> 29.97 (30000\/1001)
\nInput #0, flv, from ‘c:\/myvideo.flv’:
\nMetadata:
\nduration        : 261
\nwidth           : 480
\nheight          : 270
\nvideodatarate   : 62
\nframerate       : 30
\nvideocodecid    : 2
\naudiodatarate   : 62
\naudiosamplerate : 44100
\naudiosamplesize : 16
\nstereo          : true
\naudiocodecid    : 2
\nfilesize        : 43117478
\nDuration: 00:04:20.98, start: 0.000000, bitrate: 128 kb\/s
\nStream #0.0: Video: flv, yuv420p, 480×270, 64 kb\/s, 29.97 tbr, 1k tbn, 1k tbc
\nStream #0.1: Audio: mp3, 44100 Hz, 2 channels, s16, 64 kb\/s<\/span><\/p>\n
After the transcoding, the generated Flash video file uses an FLV video stream and an MP3<\/a> audio stream.<\/p>\n
We are now ready to modify a media file using Xuggler. But before we write code, we need to understand how MediaTool works<\/a>:<\/p>\n
MediaTool uses an event listener paradigm. The writer is automatically added as a “listener” to the reader and receives all decoded media. The IMediaViewer and IMediaWriter interfaces (what the viewer and writer actually are) implement the IMediaListener interface, and may be added as listeners to an IMediaReader.<\/span><\/p>\n
We confirmed that with our previous example. The thing is that in order to perform various modifications to an input file<\/a>, we have to set up a “media pipeline”. We create custom implementations of IMediaTool<\/a> and then set up listeners on each tool in a chain way so they pass data from one to the other.<\/p>\n
Let’s suppose we wish to add a static image to our video and at the same time we wish to reduce the audio volume. In that case, we create two custom IMediaTool<\/a> objects:<\/p>\n