Changeset 27a5b88


Ignore:
Timestamp:
May 21, 2007 1:20:38 AM (7 years ago)
Author:
yomguy <>
Branches:
master, crem, crem2, dev, dev2, diadems, feature/breadcrumbs, feature/ts-0.5, feature/ts-0.5.4, feature/writecache, forma, generic, instru_search, lam, lam2, mapsv3, merge, nlivemulti, production, release/1.4.4, sabiod, security, server, social, storage, telecaster, test, video
Children:
dfc0718
Parents:
3e80d17
git-author:
yomguy <> (21/05/2007 01:20:38)
git-committer:
yomguy <> (21/05/2007 01:20:38)
Message:

Moved audio generator to ExporterCore?.core_process

Files:
6 edited

Legend:

Unmodified
Added
Removed
  • telemeta/export/core.py

    re9a21a3 r27a5b88  
    150150        return self.dest 
    151151 
    152     def stream(self,command): 
     152    def core_process(self,command,buffer_size,dest): 
    153153        """Streams encoded audio data through a generator""" 
     154         
     155        __chunk = 0 
     156        file_out = open(dest,'w') 
     157 
    154158        proc = subprocess.Popen(command, 
    155                 shell=True, 
    156                 bufsize=self.buffer_size, 
    157                 stdin=subprocess.PIPE, 
    158                 stdout=subprocess.PIPE, 
    159                 close_fds=True) 
    160                  
    161         chunk = proc.stdout.read(self.buffer_size) 
    162         return chunk 
     159                shell = True, 
     160                bufsize = buffer_size, 
     161                stdin = subprocess.PIPE, 
     162                stdout = subprocess.PIPE, 
     163                close_fds = True) 
     164 
     165        __chunk = proc.stdout.read(buffer_size) 
     166        yield __chunk 
     167        file_out.write(__chunk) 
     168 
     169        # Processing 
     170        while __chunk: 
     171            __chunk = proc.stdout.read(buffer_size) 
     172            yield __chunk 
     173            file_out.write(__chunk) 
     174 
     175        #file_in.close() 
     176        file_out.close() 
    163177 
    164178    def post_process(self, item_id, source, metadata, ext,  
  • telemeta/export/flac.py

    re9a21a3 r27a5b88  
    8686        media.save() 
    8787         
    88     def process(self, item_id, source, metadata, options=None): 
    89         self.item_id = item_id 
    90         self.source = source 
    91         self.metadata = metadata 
    92         self.options = {} 
     88    def get_args(self,options=None): 
     89        """Get process options and return arguments for the encoder""" 
    9390        args = '' 
    94          
    9591        if not options is None: 
    9692            self.options = options 
    97              
    98             if 'verbose' in self.options and self.options['verbose'] != '0': 
    99                 args = args 
    100             else: 
     93            if not ('verbose' in self.options and self.options['verbose'] != '0'): 
    10194                args = args + ' -s ' 
    102                  
     95 
    10396            if 'flac_quality' in self.options: 
    10497                args = args+' -f -'+self.options['flac_quality'] 
     
    107100        else: 
    108101            args = args+' -s -f -'+self.quality_default 
    109      
     102        return args 
     103         
     104    def process(self, item_id, source, metadata, options=None): 
     105        self.item_id = item_id 
     106        self.source = source 
     107        self.metadata = metadata 
     108        #self.options = {} 
     109        self.args = self.get_args(options) 
     110        self.ext = self.get_file_extension() 
     111        self.command = 'sox "'+self.source+'" -q -w -r 44100 -t wav -c2 - '+ \ 
     112                       '| flac '+self.args+' -c -' 
     113 
     114        # Pre-proccessing 
    110115        try: 
    111             # Pre-proccessing (core) 
    112             self.ext = self.get_file_extension() 
    113116            self.dest = self.pre_process(self.item_id, 
    114117                                         self.source, 
     
    117120                                         self.cache_dir, 
    118121                                         self.options) 
    119                                           
    120             # Initializing 
    121             chunk = 0 
    122             file_out = open(self.dest,'w') 
    123              
    124             proc = subprocess.Popen( \ 
    125                     'sox "'+self.source+'" -q -w -r 44100 -t wav -c2 - '+ 
    126                     '| flac '+args+' -c -', 
    127                     shell=True, 
    128                     bufsize=self.buffer_size, 
    129                     stdin=subprocess.PIPE, 
    130                     stdout=subprocess.PIPE, 
    131                     close_fds=True) 
     122        except: 
     123            yield 'ExporterError [3]: pre_process' 
    132124 
    133             chunk = proc.stdout.read(self.buffer_size) 
    134             yield chunk 
    135             file_out.write(chunk) 
     125        # Processing (streaming + cache writing) 
     126        try: 
     127            stream = self.core_process(self.command,self.buffer_size,self.dest) 
     128            for chunk in stream: 
     129                yield chunk 
     130        except: 
     131            yield 'ExporterError: core_process' 
    136132 
    137             # Processing 
    138             while chunk: 
    139                 chunk = proc.stdout.read(self.buffer_size) 
    140                 yield chunk 
    141                 file_out.write(chunk)            
    142              
    143             #file_in.close() 
    144             file_out.close() 
    145  
    146             # Encoding 
    147             #os.system('flac '+args+' -o "'+self.dest+'" "'+ \ 
    148             #          self.source+'" > /dev/null') 
    149  
    150             # Post-proccessing (self) 
    151             self.write_tags() 
     133        # Post-proccessing 
     134        try: 
     135            self.write_tags()         
    152136            self.post_process(self.item_id, 
    153137                         self.source, 
     
    156140                         self.cache_dir, 
    157141                         self.options) 
     142        except: 
     143            yield 'ExporterError: post_process' 
    158144 
    159             # Output 
    160             #return self.dest 
    161145 
    162         except IOError: 
    163             yield 'ExporterError [3]: source file does not exist.' 
    164  
     146        # Encoding 
     147            #os.system('flac '+args+' -o "'+self.dest+'" "'+ \ 
     148            #          self.source+'" > /dev/null') 
  • telemeta/export/mp3.py

    re9a21a3 r27a5b88  
    9191        id3.save() 
    9292 
    93     def process(self, item_id, source, metadata, options=None): 
    94         self.item_id = item_id 
    95         self.source = source 
    96         self.metadata = metadata 
    97         self.options = {} 
     93    def get_args(self,options=None): 
     94        """Get process options and return arguments for the encoder""" 
    9895        args = '' 
    99          
    10096        if not options is None:  
    10197            self.options = options 
     
    114110        else: 
    115111            args = args + ' -S -c -o ' 
    116          
    117         if os.path.exists(self.source) and not iswav16(self.source): 
    118             self.source = self.decode() 
     112 
     113        return args 
     114 
     115    def process(self, item_id, source, metadata, options=None): 
     116        self.item_id = item_id 
     117        self.source = source 
     118        self.metadata = metadata 
     119        #self.options = {} 
     120        self.args = self.get_args(options) 
     121        self.ext = self.get_file_extension() 
     122        self.command = 'sox "'+self.source+'" -q -w -r 44100 -t wav -c2 - '+ \ 
     123                       '| lame '+self.args+' --tc "default" - -' 
    119124             
     125        # Pre-proccessing 
    120126        try: 
    121             # Pre-proccessing (core) 
    122             self.ext = self.get_file_extension() 
    123127            self.dest = self.pre_process(self.item_id, 
    124                             self.source, 
    125                             self.metadata, 
    126                             self.ext, 
    127                             self.cache_dir, 
    128                             self.options) 
    129              
    130             # Initializing 
    131             chunk = 0 
    132             file_out = open(self.dest,'w') 
    133              
    134             proc = subprocess.Popen( \ 
    135                     'sox "'+self.source+'" -q -w -r 44100 -t wav -c2 - '+ 
    136                     '| lame '+args+' --tc "default" - -', 
    137                     shell=True, 
    138                     bufsize=self.buffer_size, 
    139                     stdin=subprocess.PIPE, 
    140                     stdout=subprocess.PIPE, 
    141                     close_fds=True) 
    142                  
    143             chunk = proc.stdout.read(self.buffer_size) 
    144             yield chunk 
    145             file_out.write(chunk) 
    146             
    147             # Processing 
    148             while chunk: 
    149                 chunk = proc.stdout.read(self.buffer_size) 
     128                                         self.source, 
     129                                         self.metadata, 
     130                                         self.ext, 
     131                                         self.cache_dir, 
     132                                         self.options) 
     133        except: 
     134            yield 'ExporterError [3]: pre_process' 
     135 
     136        # Processing (streaming + cache writing) 
     137        try: 
     138            stream = self.core_process(self.command,self.buffer_size,self.dest) 
     139            for chunk in stream: 
    150140                yield chunk 
    151                 file_out.write(chunk)            
    152             
    153             file_out.close() 
    154              
    155             # Encoding 
    156             # os.system('lame '+args+' --tc "default" "'+self.source+ 
    157             #                        '" "'+self.dest+'"') 
    158              
    159             # Post-proccessing (self) 
    160             self.write_tags() 
     141        except: 
     142            yield 'ExporterError: core_process' 
     143 
     144        # Post-proccessing 
     145        try: 
     146            self.write_tags()         
    161147            self.post_process(self.item_id, 
    162148                         self.source, 
     
    165151                         self.cache_dir, 
    166152                         self.options) 
    167                          
    168             # Output 
    169             # return self.dest 
    170  
    171         except IOError: 
    172             yield 'ExporterError [3]: source file does not exist.' 
    173  
     153        except: 
     154            yield 'ExporterError: post_process' 
     155     
     156        # Encoding 
     157        # os.system('lame '+args+' --tc "default" "'+self.source+ 
     158        #                        '" "'+self.dest+'"') 
     159             
  • telemeta/export/ogg.py

    re9a21a3 r27a5b88  
    7575        media.save() 
    7676 
    77  
    78     def process(self, item_id, source, metadata, options=None): 
    79         self.item_id = item_id 
    80         self.source = source 
    81         self.metadata = metadata 
    82         self.options = {} 
     77    def get_args(self,options=None): 
     78        """Get process options and return arguments for the encoder""" 
    8379        args = '' 
    84          
    8580        if not options is None: 
    8681            self.options = options 
     
    9792            else: 
    9893                args = args + '-b '+self.bitrate_default 
    99  
    10094        else: 
    10195            args = ' -Q -b '+self.bitrate_default 
     96        return args 
    10297             
    103         #if os.path.exists(self.source) and not iswav16(self.source): 
    104         #    self.source = self.decode() 
    105          
    106         # Pre-processing 
     98 
     99    def process(self, item_id, source, metadata, options=None):         
     100        self.item_id = item_id 
     101        self.source = source 
     102        self.metadata = metadata 
     103        #self.options = {} 
     104        self.args = self.get_args(options) 
    107105        self.ext = self.get_file_extension() 
    108         self.dest = self.pre_process(self.item_id, 
    109                                      self.source, 
    110                                      self.metadata, 
    111                                      self.ext, 
    112                                      self.cache_dir, 
    113                                      self.options) 
    114         
     106        self.command = 'sox "'+self.source+'" -q -w -r 44100 -t wav -c2 - '+ \ 
     107                       '| oggenc '+self.args+' -' 
     108 
     109        # Pre-proccessing 
    115110        try: 
    116             # Initializing 
    117             chunk = 0 
    118             file_out = open(self.dest,'w') 
    119              
    120             proc = subprocess.Popen( \ 
    121                     'sox "'+self.source+'" -q -w -r 44100 -t wav -c2 - '+ 
    122                     '| oggenc '+args+' -', 
    123                     shell=True, 
    124                     bufsize=self.buffer_size, 
    125                     stdin=subprocess.PIPE, 
    126                     stdout=subprocess.PIPE, 
    127                     close_fds=True) 
     111            self.dest = self.pre_process(self.item_id, 
     112                                         self.source, 
     113                                         self.metadata, 
     114                                         self.ext, 
     115                                         self.cache_dir, 
     116                                         self.options) 
     117        except: 
     118            yield 'ExporterError [3]: pre_process' 
    128119 
    129             chunk = proc.stdout.read(self.buffer_size) 
    130             yield chunk 
    131             file_out.write(chunk) 
     120        # Processing (streaming + cache writing) 
     121        try: 
     122            stream = self.core_process(self.command,self.buffer_size,self.dest) 
     123            for chunk in stream: 
     124                yield chunk 
     125        except: 
     126            yield 'ExporterError: core_process' 
    132127 
    133             # Processing 
    134             while chunk: 
    135                 chunk = proc.stdout.read(self.buffer_size) 
    136                 yield chunk 
    137                 file_out.write(chunk)            
    138              
    139             #file_in.close() 
    140             file_out.close() 
    141                  
    142             # Post-proccessing 
    143             #os.system('sox "'+self.source+'" -w -r 44100 -t wav -c2 - \ 
    144             #      | oggenc '+args+' -o "'+self.dest+'" -') 
     128        # Post-proccessing 
     129        try: 
     130            self.write_tags()         
     131            self.post_process(self.item_id, 
     132                         self.source, 
     133                         self.metadata, 
     134                         self.ext, 
     135                         self.cache_dir, 
     136                         self.options) 
     137        except: 
     138            yield 'ExporterError: post_process' 
     139 
     140 
     141 
     142        # Post-proccessing 
     143        #os.system('sox "'+self.source+'" -w -r 44100 -t wav -c2 - \ 
     144        #      | oggenc '+args+' -o "'+self.dest+'" -') 
    145145   
    146             self.write_tags() 
    147             self.post_process(self.item_id, 
    148                             self.source, 
    149                             self.metadata, 
    150                             self.ext, 
    151                             self.cache_dir, 
    152                             self.options) 
    153                 
    154         except IOError: 
    155             yield 'ExporterError [3]: source file does not exist.' 
  • telemeta/export/wav.py

    r080a9dd r27a5b88  
    121121            file_in = open(self.source,'rb') 
    122122            file_out = open(self.dest,'w') 
    123          
     123 
    124124            chunk = file_in.read(self.buffer_size) 
    125125            yield chunk 
     
    134134            file_in.close() 
    135135            file_out.close() 
    136  
    137             #if self.compare_md5_key(): 
    138             #os.system('cp -a "'+self.source+'" "'+ self.dest+'"') 
    139             #print 'COPIED' 
    140              
    141             # Pre-proccessing (self) 
    142136            self.write_tags() 
    143137 
     
    157151                         self.options) 
    158152 
    159             # Output                 
    160             #return self.dest 
    161  
    162153        except IOError: 
    163154            yield 'ExporterError [3]: source file does not exist.' 
    164155 
     156 
     157 
     158            #if self.compare_md5_key(): 
     159            #os.system('cp -a "'+self.source+'" "'+ self.dest+'"') 
     160            #print 'COPIED' 
     161             
  • tests/export_test.py

    re9a21a3 r27a5b88  
    2828         'publisher': 'Parisson', 
    2929         } 
    30 options = {'verbose': '0'} 
     30options = {'verbose': '1'} 
    3131 
    3232class ExportTest(Component): 
     
    4646            for chunk in stream: 
    4747                pass 
     48                #print chunk 
    4849             
    4950compmgr = ComponentManager() 
Note: See TracChangeset for help on using the changeset viewer.